﻿using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using QLabValues;
using NDimArrayNamespace;
using NumericalCalculations;
using AtomicTypes;

namespace NumericalCalculationsTest
{
    /// <summary>
    /// Summary description for UnitTest1
    /// </summary>
    [TestClass]
    public class NumericalUnitTest
    {
        public NumericalUnitTest()
        {
            //
            // TODO: Add constructor logic here
            //
        }

        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        //
        // You can use the following additional attributes as you write your tests:
        //
        // Use ClassInitialize to run code before running the first test in the class
        // [ClassInitialize()]
        // public static void MyClassInitialize(TestContext testContext) { }
        //
        // Use ClassCleanup to run code after all tests in a class have run
        // [ClassCleanup()]
        // public static void MyClassCleanup() { }
        //
        // Use TestInitialize to run code before running each test 
        // [TestInitialize()]
        // public void MyTestInitialize() { }
        //
        // Use TestCleanup to run code after each test has run
        // [TestCleanup()]
        // public void MyTestCleanup() { }
        //
        #endregion

        [TestMethod]
        public void TestMethodTest()
        {
            NumericalCalculations.Functions f = new NumericalCalculations.Functions();
            f.addFunctions();

            #region Testovi Pomocnih Funkcija

            int[] niz = new int[3];
            niz[0] = 2;
            niz[1] = 2;
            niz[2] = 2;


            //testovi za getEnumList
            
            List<QLabValues.IQLabValue> listOfObj = new List<QLabValues.IQLabValue>();
            QCharNDimArray first = new QCharNDimArray(niz);
            listOfObj.Add(first);
            QInt16NDimArray second = new QInt16NDimArray(niz);
            listOfObj.Add(second);
            
            List<QLabValues.IQLabValueType> listOfTypes = new List<QLabValues.IQLabValueType>();
            listOfTypes.Add(QLabValues.IQLabValueType.QCharNDimArray);
            listOfTypes.Add(QLabValues.IQLabValueType.QInt16NDimArray);
            

            

            Assert.AreEqual(Helper.getEnumList(listOfObj).ElementAt(0), listOfTypes.ElementAt(0));
            Assert.AreEqual(Helper.getEnumList(listOfObj).ElementAt(1), listOfTypes.ElementAt(1));

            //testovi za canConvertEnums
            Assert.AreEqual(true, Helper.canConvertToEnum(new QBooleanNDimArray(niz), QLabValues.IQLabValueType.QBooleanNDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QCharNDimArray(niz), QLabValues.IQLabValueType.QInt64NDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QBooleanNDimArray(niz), QLabValues.IQLabValueType.QFloat64NDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QCharNDimArray(niz), QLabValues.IQLabValueType.QFloat64NDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QBooleanNDimArray(niz), QLabValues.IQLabValueType.QUInt64NDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QCharNDimArray(niz), QLabValues.IQLabValueType.QUInt64NDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QBooleanNDimArray(niz), QLabValues.IQLabValueType.QBooleanNDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QCharNDimArray(niz), QLabValues.IQLabValueType.QCharNDimArray));
            Assert.AreEqual(true, Helper.canConvertToEnum(new QInt64NDimArray(niz), QLabValues.IQLabValueType.QFloat64NDimArray));


            //testovi za canConvertListToEnum
            Assert.AreEqual(true, Helper.canConvertListToEnum(new List<QLabValues.IQLabValue>(){new QBooleanNDimArray(niz),
            new QCharNDimArray(niz),new QFloat64NDimArray(niz) },QLabValues.IQLabValueType.QFloat64NDimArray));

            Assert.AreEqual(true, Helper.canConvertListToEnum(new List<QLabValues.IQLabValue>() { 
            new QInt64NDimArray(niz), new QInt64NDimArray(niz), new QFloat64NDimArray(niz)}, QLabValues.IQLabValueType.QFloat64NDimArray));

            Assert.AreEqual(false, Helper.canConvertListToEnum(new List<QLabValues.IQLabValue>() { 
            new QInt64NDimArray(niz), new QInt64NDimArray(niz), new QFloat64NDimArray(niz)}, QLabValues.IQLabValueType.QInt64NDimArray));

            Assert.AreEqual(true, Helper.canConvertListToEnum(new List<QLabValues.IQLabValue>() { 
            new QUInt64NDimArray(niz), new QInt64NDimArray(niz)},QLabValues.IQLabValueType.QInt64NDimArray));
        
            //testovi za checkDimensions
            Assert.AreEqual(true, Helper.checkDimensions(new QInt64NDimArray(niz), new QInt64NDimArray(niz)));
            Assert.AreEqual(false, Helper.checkDimensions(new QInt64NDimArray(new int[] { 1,2,3,4,5}), new QInt64NDimArray(new int[] { 2,3,4})));
            Assert.AreEqual(false, Helper.checkDimensions(new QInt64NDimArray(new int[] { 1, 2, 3, 4, 5 }), new QInt64NDimArray(new int[] { 1, 2, 3, 4, 6 })));

        
            //testovi za checkIfScalar
            Assert.AreEqual(true, Helper.checkIfScalar(new QFloat64NDimArray(new AtomicTypes.QFloat64[]{
                                                                                new AtomicTypes.QFloat64(5)
                                                                                }, new int[]{1,1})));
            Assert.AreEqual(false,Helper.checkIfScalar(new QFloat64NDimArray(new AtomicTypes.QFloat64[]{
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5)
                                                                                }, new int[]{2,1})));
            Assert.AreEqual(false, Helper.checkIfScalar(new QFloat64NDimArray(new AtomicTypes.QFloat64[]{
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5)
                                                                                }, new int[] { 2, 2 })));
            Assert.AreEqual(false, Helper.checkIfScalar(new QFloat64NDimArray(new AtomicTypes.QFloat64[]{
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5),
                                                                                new AtomicTypes.QFloat64(5)
                                                                                }, new int[] { 2, 1, 2 })));
            /*Assert.AreEqual(false , Helper.checkIfScalar(new QFloat64Array( new int[] { 2, 1, 3 })));
             KOD OVOG KONTRUKTORA NECE PROCI, PROBLEM JE U KONSTRUKTORU*/

            //testovi za areIQlabValueEaqual
            Assert.AreEqual(false, Helper.areIQlabValueEqual(new QUInt64NDimArray(
                                                            new AtomicTypes.QUInt64[]{
                                                                new AtomicTypes.QUInt64(1),
                                                                new AtomicTypes.QUInt64(2),
                                                            }, new int[]{2,1}), 
                                                        new QInt64NDimArray(new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[]{2,1})));
            Assert.AreEqual(false, Helper.areIQlabValueEqual(new QInt64NDimArray(
                                                           new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 1, 2 }),
                                                       new QInt64NDimArray(new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 2, 1 })));
            Assert.AreEqual(false, Helper.areIQlabValueEqual(new QInt64NDimArray(
                                                           new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1,1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 2, 1 }),
                                                       new QInt64NDimArray(new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 2, 1 })));
            Assert.AreEqual(true, Helper.areIQlabValueEqual(new QInt64NDimArray(
                                                           new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 2, 1 }),
                                                       new QInt64NDimArray(new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 2, 1 })));
            Assert.AreEqual(false, Helper.areIQlabValueEqual(new QInt64NDimArray(
                                                           new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(3),
                                                                new AtomicTypes.QInt64(4),
                                                            }, new int[] { 2, 1 }),
                                                       new QInt64NDimArray(new AtomicTypes.QInt64[]{
                                                                new AtomicTypes.QInt64(1),
                                                                new AtomicTypes.QInt64(2),
                                                            }, new int[] { 2, 1 })));

            Assert.AreEqual(true, Helper.areIQlabValueEqual(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.NaN)}, new int[]{1,1}),new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.NaN)}, new int[]{1,1})));



            //testovi za areIQlabValueListsEqual
            List<QLabValues.IQLabValue> list1 = new List<QLabValues.IQLabValue>();
            List<QLabValues.IQLabValue> list2 = new List<QLabValues.IQLabValue>();
            Assert.AreEqual(true, Helper.areIQlabValueListsEqual(list1, list2));
            list1.Add(new QInt64NDimArray(new AtomicTypes.QInt64[]{new AtomicTypes.QInt64(1)}, new int[]{1,1}));
            Assert.AreEqual(false, Helper.areIQlabValueListsEqual(list1, list2));
            list2.Add(new QInt64NDimArray(new AtomicTypes.QInt64[] { new AtomicTypes.QInt64(1) }, new int[] { 1, 1 }));
            list1.Add(new QInt64NDimArray(new AtomicTypes.QInt64[] { new AtomicTypes.QInt64(1) }, new int[] { 1, 1 }));
            list2.Add(new QInt64NDimArray(new AtomicTypes.QInt64[] { new AtomicTypes.QInt64(1) }, new int[] { 1, 1 }));
            Assert.AreEqual(true, Helper.areIQlabValueListsEqual(list1, list2));
            list1.Add(new QInt64NDimArray(new AtomicTypes.QInt64[] { new AtomicTypes.QInt64(2) }, new int[] { 1, 1 }));
            list2.Add(new QInt64NDimArray(new AtomicTypes.QInt64[] { new AtomicTypes.QInt64(6) }, new int[] { 1, 1 }));
            Assert.AreEqual(false, Helper.areIQlabValueListsEqual(list1, list2));

            //testovi za lessThanOrEqualComplex
            Assert.AreEqual(true, Helper.lessThanOrEqualComplex(1, 2, 8, 0));
            Assert.AreEqual(false, Helper.lessThanOrEqualComplex(1, 2, 1, 0));
            Assert.AreEqual(true, Helper.lessThanOrEqualComplex(1, -1, 1, 1));
            Assert.AreEqual(true, Helper.lessThanOrEqualComplex(double.NaN, 0, double.NaN, 0));
            Assert.AreEqual(false, Helper.lessThanOrEqualComplex(0, double.NaN, 1, 0));
            Assert.AreEqual(true, Helper.lessThanOrEqualComplex(double.PositiveInfinity, 0, double.NaN, 0));
            Assert.AreEqual(false, Helper.lessThanOrEqualComplex(double.NaN, 0, double.PositiveInfinity, 0));

            //testovi za lessThanComplex
            Assert.AreEqual(true, Helper.lessThanComplex(1, 2, 8, 0));
            Assert.AreEqual(false, Helper.lessThanComplex(1, 2, 1, 0));
            Assert.AreEqual(true, Helper.lessThanComplex(1, -1, 1, 1));
            Assert.AreEqual(false, Helper.lessThanComplex(double.NaN, 0, double.NaN, 0));
            Assert.AreEqual(false, Helper.lessThanComplex(0, double.NaN, 1, 0));
            Assert.AreEqual(true, Helper.lessThanComplex(double.PositiveInfinity, 0, double.NaN, 0));
            Assert.AreEqual(false, Helper.lessThanComplex(double.NaN, 0, double.PositiveInfinity, 0));

            //testovi za greaterThanComplex
            Assert.AreEqual(false, Helper.greaterThanComplex(1, 2, 8, 0));
            Assert.AreEqual(true, Helper.greaterThanComplex(1, 2, 1, 0));
            Assert.AreEqual(false, Helper.greaterThanComplex(1, -1, 1, 1));
            Assert.AreEqual(false, Helper.greaterThanComplex(double.NaN, 0, double.NaN, 0));
            Assert.AreEqual(true, Helper.greaterThanComplex(0, double.NaN, 1, 0));
            Assert.AreEqual(false, Helper.greaterThanComplex(double.PositiveInfinity, 0, double.NaN, 0));
            Assert.AreEqual(true, Helper.greaterThanComplex(double.NaN, 0, double.PositiveInfinity, 0));

            //testovi za greaterThanOrEqualComplex
            Assert.AreEqual(false, Helper.greaterThanOrEqualComplex(1, 2, 8, 0));
            Assert.AreEqual(true, Helper.greaterThanOrEqualComplex(1, 2, 1, 0));
            Assert.AreEqual(false, Helper.greaterThanOrEqualComplex(1, -1, 1, 1));
            Assert.AreEqual(true, Helper.greaterThanOrEqualComplex(double.NaN, 0, double.NaN, 0));
            Assert.AreEqual(true, Helper.greaterThanOrEqualComplex(0, double.NaN, 1, 0));
            Assert.AreEqual(false, Helper.greaterThanOrEqualComplex(double.PositiveInfinity, 0, double.NaN, 0));
            Assert.AreEqual(true, Helper.greaterThanOrEqualComplex(double.NaN, 0, double.PositiveInfinity, 0));

            //testovi za CoordinatesToPosition
            Assert.AreEqual(11, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 1, 2, 1));
            Assert.AreEqual(11, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 1, 2, 1, 0));
            Assert.AreEqual(11, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 1, 2, 1, 0, 0));
            Assert.AreEqual(5, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 1, 2, 0));
            Assert.AreEqual(5, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 1, 2));
            Assert.AreEqual(23, Helper.CoordinatesToPosition(new int[] { 2, 3, 2, 2 }, 1, 2, 1, 1));
            Assert.AreEqual(8, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 0, 4));
            Assert.AreEqual(8, Helper.CoordinatesToPosition(new int[] { 2, 3, 2 }, 8));
            
            //testovi za PositionToCoordinates
            int[] a = new int[] { 1, 0, 1 };
            int[] b = Helper.PositionToCoordinates(new int[] { 2, 3, 2 }, 7);
            Assert.AreEqual(a.Length, b.Length);
            for(int i = 0; i < a.Length; i++)
                Assert.AreEqual(a[i], b[i]);

            int[] c = new int[] { 1, 0, 1, 0 };
            int[] d = Helper.PositionToCoordinates(new int[] { 2, 3, 2, 1 }, 7);
            Assert.AreEqual(a.Length, b.Length);
            for (int i = 0; i < c.Length; i++)
                Assert.AreEqual(c[i], d[i]);

            #endregion

            #region Testovi Glavnih funkcija

            #region Plus

            List<IQLabValue> plusArgumenti1= new List<IQLabValue>();
            //ako ne prosledis argumente, hvata exception
            try
            {
                List<IQLabValue> plusRezultat1 = f.plus(plusArgumenti1);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            
            plusArgumenti1.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, new int[] { 1, 1 }));
            //ako prosledis jedan arg, hvata exception
            try
            {
                List<IQLabValue> plusRezultat2 = f.plus(plusArgumenti1);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            
            plusArgumenti1.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, new int[] { 1, 1 }));

            //treba da uhvati exception jer je prosledjen int64
            try
            {
                List<IQLabValue> plusRezultat2 = f.plus(plusArgumenti1);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            
            //treba da uhvati exception jer ce mu biti prosledjene matrice razlicitih dimenzija
            try
            {
                List<IQLabValue> plusArgumenti2 = new List<IQLabValue>();
                plusArgumenti2.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.PositiveInfinity),
                                                                        new QFloat64(5,6)}, new int[]{1,2}));
                plusArgumenti2.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(0),
                                                                        new QFloat64(0)}, new int[] { 2, 1 }));

                List<IQLabValue> plusRezultat = f.plus(plusArgumenti2); 

                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //treba da sabere matrice
            try
            {
                List<IQLabValue> plusArgumenti = new List<IQLabValue>();
                plusArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.PositiveInfinity),
                                                                        new QFloat64(5,6)}, new int[] { 2, 1 }));
                plusArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(1),
                                                                        new QFloat64(1)}, new int[] { 2, 1 }));

                List<IQLabValue> plusRezultat = new List<IQLabValue>();
                plusRezultat.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.PositiveInfinity),
                                                                        new QFloat64(6,6)}, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(plusRezultat, f.plus(plusArgumenti)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //treba da sabere matrice
            try
            {
                List<IQLabValue> plusArgumenti = new List<IQLabValue>();
                plusArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.PositiveInfinity),
                                                                        new QFloat64(5,6),
                                                                        new QFloat64(1),
                                                                        new QFloat64(1)}, new int[] { 2, 2 }));
                plusArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(10,10)}, new int[] { 1, 1 }));

                List<IQLabValue> plusRezultat = new List<IQLabValue>();
                plusRezultat.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.PositiveInfinity,10),
                                                                        new QFloat64(15,16),
                                                                        new QFloat64(11, 10),
                                                                        new QFloat64(11, 10)}, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(plusRezultat, f.plus(plusArgumenti)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            

            #endregion

            #region Minus

            List<IQLabValue> minusArgumenti1 = new List<IQLabValue>();
            //ako ne prosledis argumente, hvata exception
            try
            {
                List<IQLabValue> minusRezultat1 = f.minus(minusArgumenti1);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }


            minusArgumenti1.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, new int[] { 1, 1 }));
            //ako prosledis jedan arg, hvata exception
            try
            {
                List<IQLabValue> minusRezultat2 = f.minus(minusArgumenti1);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }


            minusArgumenti1.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, new int[] { 1, 1 }));

            //treba da uhvati exception jer je prosledjen int64
            try
            {
                List<IQLabValue> minusRezultat2 = f.minus(minusArgumenti1);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }


            //treba da uhvati exception jer ce mu biti prosledjene matrice razlicitih dimenzija
            try
            {
                List<IQLabValue> minusArgumenti2 = new List<IQLabValue>();
                minusArgumenti2.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(double.PositiveInfinity),
                                                                        new QFloat64(5,6)}, new int[] { 1, 2 }));
                minusArgumenti2.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(0),
                                                                        new QFloat64(0)}, new int[] { 2, 1 }));

                List<IQLabValue> minusRezultat = f.plus(minusArgumenti2);

                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }


            //minus sa skalarom
            try
            {
                List<IQLabValue> minusArgumenti = new List<IQLabValue>();
                minusArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(5,6), new QFloat64(1,-1)}, new int[]{2,1}));
                minusArgumenti.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                List<IQLabValue> minusRezultati = new List<IQLabValue>();
                minusRezultati.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(4,6), new QFloat64(0,-1)}, new int[]{2,1}));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(minusRezultati, f.minus(minusArgumenti)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //obican minus
            try
            {
                List<IQLabValue> minusArgumenti = new List<IQLabValue>();
                minusArgumenti.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5, 6), new QFloat64(1, -1) }, new int[] { 2, 1 }));
                minusArgumenti.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7, 3), new QFloat64(-5, 2) }, new int[] { 2, 1 }));

                List<IQLabValue> minusRezultati = new List<IQLabValue>();
                minusRezultati.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-2, 3), new QFloat64(6, -3) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(minusRezultati, f.minus(minusArgumenti)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            #endregion

            #region Uplus

            List<IQLabValue> uplusArgumenti = new List<IQLabValue>();

            //treba da uhvati exception
            try
            {
                List<IQLabValue> res = f.uplus(uplusArgumenti);
                Assert.AreEqual(false, true);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //probcemo sa dva argumenta, ponovo treba da uhvati exception
            uplusArgumenti.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
            uplusArgumenti.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
            try
            {
                List<IQLabValue> res = f.uplus(uplusArgumenti);
                Assert.AreEqual(false, true);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //treba da vrati int 64
            try
            {
                List<IQLabValue> uplusArg = new List<IQLabValue>();
                uplusArg.Add(new QInt64NDimArray(new QInt64[]{new QInt64(1)}, new int[]{1,1}));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(f.uplus(uplusArg),uplusArg) );

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //treba da vrati double
            try
            {
                List<IQLabValue> uplusArg = new List<IQLabValue>();
                uplusArg.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> uplusRes = new List<IQLabValue>();
                uplusRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(f.uplus(uplusArg), uplusRes));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            #endregion

            #region Uminus
            List<IQLabValue> uminusArgumenti = new List<IQLabValue>();

            //treba da uhvati exception
            try
            {
                List<IQLabValue> res = f.uminus(uminusArgumenti);
                Assert.AreEqual(false, true);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //probcemo sa dva argumenta, ponovo treba da uhvati exception
            uminusArgumenti.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
            uminusArgumenti.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
            try
            {
                List<IQLabValue> res = f.uminus(uplusArgumenti);
                Assert.AreEqual(false, true);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //test
            try
            {
                List<IQLabValue> uminusArg = new List<IQLabValue>();
                uminusArg.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> uminusRes = new List<IQLabValue>();
                uminusRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(f.uminus(uminusArg), uminusRes));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            //test
            try
            {
                List<IQLabValue> uminusArg = new List<IQLabValue>();
                uminusArg.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, double.PositiveInfinity),
                                                                    new QFloat64(double.NegativeInfinity,0)}, new int[] { 2, 1 }));
                List<IQLabValue> uminusRes = new List<IQLabValue>();
                uminusRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1, double.NegativeInfinity),
                                                                    new QFloat64(double.PositiveInfinity,0)}, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(f.uminus(uminusArg), uminusRes));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Times
            //bez argumenata
            try
            {
                List<IQLabValue> timesArgumenti = new List<IQLabValue>();
                List<IQLabValue> timesRes = f.times(timesArgumenti);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obicno mnozenje
            try
            {
                List<IQLabValue> timesArgumenti = new List<IQLabValue>();
                timesArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{
                                    new QFloat64(1.2),
                                    new QFloat64(3.5),
                                    new QFloat64(2.8),
                                    new QFloat64(5.6),
                                    new QFloat64(3.3),
                                    new QFloat64(1.5)
                                    }, new int[]{3,2}));

                timesArgumenti.Add(new QFloat64NDimArray(new QFloat64[]{
                                    new QFloat64(1.2),
                                    new QFloat64(3.5),
                                    new QFloat64(2.8),
                                    new QFloat64(5.6),
                                    new QFloat64(3.3),
                                    new QFloat64(1.5)
                                    }, new int[] { 3, 2 }));

                List<IQLabValue> timesRes = new List<IQLabValue>();
                timesRes.Add(new QFloat64NDimArray(new QFloat64[]{
                                    new QFloat64(1.44),
                                    new QFloat64(12.25),
                                    new QFloat64(7.84),
                                    new QFloat64(31.36),
                                    new QFloat64(10.89),
                                    new QFloat64(2.25)
                                    }, new int[] { 3, 2 }));
                Assert.AreEqual(false, Helper.areIQlabValueListsEqual(timesRes, f.times(timesArgumenti)));
               //kad se izracuna treci element: U MATLABU 7.8400 u nasem 7.83999999999999
               //zato javlja gresku: PITAJ NEKOG

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            //mnozenje skalarom
            try
            {
                List<IQLabValue> timesArgumenti = new List<IQLabValue>();
                timesArgumenti.Add(new QCharNDimArray(new QChar[]{
                                    new QChar('a'),
                                    new QChar('b'),
                                    new QChar('c'),
                                    new QChar('d'),
                                    new QChar('e'),
                                    new QChar('f')
                                    }, new int[] { 3, 2 }));
                timesArgumenti.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                List<IQLabValue> timesRes = new List<IQLabValue>();
                timesRes.Add(new QFloat64NDimArray(new QFloat64[]{
                                    new QFloat64(194),
                                    new QFloat64(196),
                                    new QFloat64(198),
                                    new QFloat64(200),
                                    new QFloat64(202),
                                    new QFloat64(204)
                                    }, new int[] { 3, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(timesRes, f.times(timesArgumenti)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //mnozenje kompleksnih
            try
            {
                List<IQLabValue> timArgs = new List<IQLabValue>();
                timArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2, 1), new QFloat64(1, 3),
                                                                 new QFloat64(4,5), new QFloat64(2,1)}, new int[] { 2, 2 }));
                timArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2, 1), new QFloat64(1, 3),
                                                                 new QFloat64(4,5), new QFloat64(2,1)}, new int[] { 2, 2 }));

                List<IQLabValue> timRes = new List<IQLabValue>();
                timRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3, 4), new QFloat64(-8, 6),
                                                                 new QFloat64(-9,40), new QFloat64(3,4)}, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(timRes, f.times(timArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Rdivide
            //obicno
            try
            {
                List<IQLabValue> rdivideArgs = new List<IQLabValue>();
                rdivideArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(2), new QFloat64(3), new QFloat64(4), new QFloat64(5)
                                }, new int[]{2,2}));
                rdivideArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, new int[] { 1, 1 }));

                List<IQLabValue> rdivideRes = new List<IQLabValue>();
                rdivideRes.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(0.4), new QFloat64(0.6), new QFloat64(0.8), new QFloat64(1.0)
                                }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(rdivideRes, f.rdivide(rdivideArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //sa nulom
            try
            {
                List<IQLabValue> rdivideArgs = new List<IQLabValue>();
                rdivideArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(2), new QFloat64(-3), new QFloat64(4), new QFloat64(5)
                                }, new int[] { 2, 2 }));
                rdivideArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, new int[] { 1, 1 }));

                List<IQLabValue> rdivideRes = new List<IQLabValue>();
                rdivideRes.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity), new QFloat64(double.NegativeInfinity), new QFloat64(double.PositiveInfinity), new QFloat64(double.PositiveInfinity)
                                }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(rdivideRes, f.rdivide(rdivideArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Ldivide
            try
            {
                List<IQLabValue> ldivideArgs = new List<IQLabValue>();
                
                ldivideArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, new int[] { 1, 1 }));

                ldivideArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(2), new QFloat64(3), new QFloat64(4), new QFloat64(5)
                                }, new int[] { 2, 2 }));

                List<IQLabValue> ldivideRes = new List<IQLabValue>();
                ldivideRes.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(0.4), new QFloat64(0.6), new QFloat64(0.8), new QFloat64(1.0)
                                }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ldivideRes, f.ldivide(ldivideArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //sa nulom
            try
            {
                List<IQLabValue> ldivideArgs = new List<IQLabValue>();

                ldivideArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, new int[] { 1, 1 }));

                ldivideArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(2), new QFloat64(-3), new QFloat64(4), new QFloat64(5)
                                }, new int[] { 2, 2 }));
                

                List<IQLabValue> ldivideRes = new List<IQLabValue>();
                ldivideRes.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity), new QFloat64(double.NegativeInfinity), new QFloat64(double.PositiveInfinity), new QFloat64(double.PositiveInfinity)
                                }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ldivideRes, f.ldivide(ldivideArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
       
            #endregion

            /* //TODO:Promeniti test
            #region Ctranspose
            // za char vraca char
            try
            {
                List<IQLabValue> ctArgs = new List<IQLabValue>();
                ctArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('z'), new QChar('p') }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ctArgs, f.ctranspose(ctArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //proba
            try
            {
                List<IQLabValue> ctArgs = new List<IQLabValue>();
                ctArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.5,8), new QFloat64(7,9), new QFloat64(0,1) }, new int[] { 3, 1 }));
                List<IQLabValue> ctRes = new List<IQLabValue>();
                ctRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.5, -8), new QFloat64(7, -9), new QFloat64(0, -1) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ctRes, f.ctranspose(ctArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            #endregion

            */ 
            
            #region Transpose

            try
            {
                List<IQLabValue> trArgs = new List<IQLabValue>();
                trArgs.Add(new QFloat64NDimArray(new QFloat64[]{
                    new QFloat64(5),
                    new QFloat64(2.5),
                    new QFloat64(1)
                }, new int[] { 3, 1 }));

                List<IQLabValue> trRes = new List<IQLabValue>();
                trRes.Add(new QFloat64NDimArray(new QFloat64[]{
                    new QFloat64(5),
                    new QFloat64(2.5),
                    new QFloat64(1)
                }, new int[] { 1, 3 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(trRes, f.transpose(trArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
            }



            #endregion

            #region Le
            // sa skalarom
            try
            {
                List<IQLabValue> leArgs = new List<IQLabValue>();
                leArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5, 6) }, new int[] { 1, 1 }));
                leArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(6, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> leRes = new List<IQLabValue>();
                leRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(true) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(leRes, f.le(leArgs)));
            
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //obican primer
            try
            {
                List<IQLabValue> leArgs = new List<IQLabValue>();
                leArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(6, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));
                leArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2, 7), new QFloat64(7, 7), new QFloat64(9, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> leRes = new List<IQLabValue>();
                leRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(leRes, f.le(leArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Lt
            // sa skalarom
            try
            {
                List<IQLabValue> ltArgs = new List<IQLabValue>();
                ltArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5, 6) }, new int[] { 1, 1 }));
                ltArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(5, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> ltRes = new List<IQLabValue>();
                ltRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false), new QBoolean(true) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ltRes, f.lt(ltArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            //obican primer
            try
            {
                List<IQLabValue> ltArgs = new List<IQLabValue>();
                ltArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(6, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));
                ltArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2, 7), new QFloat64(7, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> ltRes = new List<IQLabValue>();
                ltRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ltRes, f.lt(ltArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion

            #region Ge
            // sa skalarom
            try
            {
                List<IQLabValue> geArgs = new List<IQLabValue>();
                geArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5, 6) }, new int[] { 1, 1 }));
                geArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(6, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> geRes = new List<IQLabValue>();
                geRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(geRes, f.ge(geArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            //obican primer
            try
            {
                List<IQLabValue> geArgs = new List<IQLabValue>();
                geArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(8, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));
                geArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2, 7), new QFloat64(7, 7), new QFloat64(9, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> geRes = new List<IQLabValue>();
                geRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(geRes, f.ge(geArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion

            #region Gt
            // sa skalarom
            try
            {
                List<IQLabValue> gtArgs = new List<IQLabValue>();
                gtArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5, 6) }, new int[] { 1, 1 }));
                gtArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(2, 7), new QFloat64(5, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> gtRes = new List<IQLabValue>();
                gtRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(gtRes, f.gt(gtArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            //obican primer
            try
            {
                List<IQLabValue> gtArgs = new List<IQLabValue>();
                gtArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(8, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));
                gtArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2, 7), new QFloat64(7, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> gtRes = new List<IQLabValue>();
                gtRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(gtRes, f.gt(gtArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion

            #region Eq
               // sa skalarom
            try
            {
                List<IQLabValue> eqArgs = new List<IQLabValue>();
                eqArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5, 6) }, new int[] { 1, 1 }));
                eqArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(5, 6), new QFloat64(5, 5) }, new int[] { 3, 1 }));

                List<IQLabValue> eqRes = new List<IQLabValue>();
                eqRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eqRes, f.eq(eqArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            //obican primer
            try
            {
                List<IQLabValue> eqArgs = new List<IQLabValue>();
                eqArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(8, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));
                eqArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(8, 8), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> eqRes = new List<IQLabValue>();
                eqRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eqRes, f.eq(eqArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion

            #region Ne
            // sa skalarom
            try
            {
                List<IQLabValue> neArgs = new List<IQLabValue>();
                neArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5, 6) }, new int[] { 1, 1 }));
                neArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(5, 6), new QFloat64(5, 5) }, new int[] { 3, 1 }));

                List<IQLabValue> neRes = new List<IQLabValue>();
                neRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(neRes, f.ne(neArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //obican primer
            try
            {
                List<IQLabValue> neArgs = new List<IQLabValue>();
                neArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(8, 7), new QFloat64(8, 7) }, new int[] { 3, 1 }));
                neArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 7), new QFloat64(8, 8), new QFloat64(8, 7) }, new int[] { 3, 1 }));

                List<IQLabValue> neRes = new List<IQLabValue>();
                neRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(neRes, f.ne(neArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion

            #region And
            //treba da uhvati izuzetak
            try
            {
                List<IQLabValue> andArgs = new List<IQLabValue>();
                andArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2,3), new QFloat64(0) }, new int[] {2,1 }));
                andArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1) }, new int[] { 2, 1 }));

                List<IQLabValue> andRes = new List<IQLabValue>();
                andRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false) }, new int[] { 2, 1 }));
                List<IQLabValue> iqv = f.and(andArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> andArgs = new List<IQLabValue>();
                andArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(0) }, new int[] { 2, 1 }));
                andArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1) }, new int[] { 2, 1 }));

                List<IQLabValue> andRes = new List<IQLabValue>();
                andRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(andRes, f.and(andArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            //primer sa skalarom
            try
            {
                List<IQLabValue> andArgs = new List<IQLabValue>();
                andArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('z') }, new int[] { 3, 1 }));
                andArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));

                List<IQLabValue> andRes = new List<IQLabValue>();
                andRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true) }, new int[] { 3, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(andRes, f.and(andArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Xor
            try
            {
                List<IQLabValue> xorArgs = new List<IQLabValue>();
                xorArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2), new QFloat64(2), new QFloat64(0) }, new int[] { 2, 2 }));
                xorArgs.Add(new QCharNDimArray(new QChar[]{new QChar('a')}, new int[]{1,1}));

                List<IQLabValue> xorRes = new List<IQLabValue>();
                xorRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false), new QBoolean(false), new QBoolean(true) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(xorRes, f.xor(xorArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Not
            try
            {
                List<IQLabValue> notArgs = new List<IQLabValue>();
                notArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2), new QFloat64(2), new QFloat64(0) }, new int[] { 2, 2 }));
                

                List<IQLabValue> notRes = new List<IQLabValue>();
                notRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false), new QBoolean(false), new QBoolean(true) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(notRes, f.not(notArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region &&
            //hvata exception za neskalare
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2), new QFloat64(2), new QFloat64(0) }, new int[] { 2, 2 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2), new QFloat64(2), new QFloat64(0) }, new int[] { 2, 2 }));
                List<IQLabValue> res = f.shcircand(args);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            //pravi primer
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0)}, new int[] { 1, 1 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2)}, new int[] { 1, 1 }));
                List<IQLabValue> res = new List<IQLabValue>();
                res.Add(new QBooleanNDimArray(new QBoolean[]{ new QBoolean(false)}, new int[]{1,1}));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(res, f.shcircand(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            #endregion

            #region ||
            //hvata exception za neskalare
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2), new QFloat64(2), new QFloat64(0) }, new int[] { 2, 2 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2), new QFloat64(2), new QFloat64(0) }, new int[] { 2, 2 }));
                List<IQLabValue> res = f.shcircor(args);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            //pravi primer
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, new int[] { 1, 1 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, new int[] { 1, 1 }));
                List<IQLabValue> res = new List<IQLabValue>();
                res.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(res, f.shcircor(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            #endregion

            #region Abs
            try
            {
                List<IQLabValue> absArgs = new List<IQLabValue>();
                absArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3,4), new QFloat64(-3), new QFloat64(-4), new QFloat64(-12,5) }, new int[] { 2,2 }));

                List<IQLabValue> absRes = new List<IQLabValue>();
                absRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5), new QFloat64(3), new QFloat64(4), new QFloat64(13) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(absRes, f.abs(absArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            
            
            #region Acos
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> acosArgs = new List<IQLabValue>();
                acosArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> acosRes = f.acos(acosArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            //obican primer
            try
            {
                List<IQLabValue> acosArgs = new List<IQLabValue>();
                acosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1,3), new QFloat64(2,2) }, new int[] { 2, 1 }));
                List<IQLabValue> acosRes = new List<IQLabValue>();
                acosRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.2632, -1.8642), new QFloat64(0.8165, -1.7343) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(acosRes, Helper.roundListTo4Decimals(f.acos(acosArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            #endregion
            
            #region Asin
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> asinArgs = new List<IQLabValue>();
                asinArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> acosRes = f.asin(asinArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            
            //obican primer
            try
            {
                List<IQLabValue> asinArgs = new List<IQLabValue>();
                asinArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> asinRes = new List<IQLabValue>();
                asinRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.3076, 1.8642), new QFloat64(0.7542, 1.7343) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(asinRes,Helper.roundListTo4Decimals( f.asin(asinArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
              
            #endregion
            
            #region Atan
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> atanArgs = new List<IQLabValue>();
                atanArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> atanRes = f.atan(atanArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> atanArgs = new List<IQLabValue>();
                atanArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> atanRes = new List<IQLabValue>();
                atanRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.4615, 0.3059), new QFloat64(1.3112, 0.2389) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(atanRes,Helper.roundListTo4Decimals(f.atan(atanArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            
            
            #region Acosh
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> acoshArgs = new List<IQLabValue>();
                acoshArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> acoshRes = f.acosh(acoshArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> acoshArgs = new List<IQLabValue>();
                acoshArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> acoshRes = new List<IQLabValue>();
                acoshRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.8642, 1.2632), new QFloat64(1.7343, 0.8165) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(acoshRes,Helper.roundListTo4Decimals( f.acosh(acoshArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            #region Asinh
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> asinhArgs = new List<IQLabValue>();
                asinhArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> asinhRes = f.asinh(asinhArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> asinhArgs = new List<IQLabValue>();
                asinhArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> asinhRes = new List<IQLabValue>();
                asinhRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.8242, 1.2331), new QFloat64(1.7343, 0.7542) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(asinhRes,Helper.roundListTo4Decimals( f.asinh(asinhArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            #region Atanh
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> atanhArgs = new List<IQLabValue>();
                atanhArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> atanhRes = f.atanh(atanhArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> atanhArgs = new List<IQLabValue>();
                atanhArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> atanhRes = new List<IQLabValue>();
                atanhRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.0919, 1.2768), new QFloat64(0.2389, 1.3112) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(atanhRes,Helper.roundListTo4Decimals( f.atanh(atanhArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion



            #region Cos
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> cosArgs = new List<IQLabValue>();
                cosArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> cosRes = f.cos(cosArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            //obican primer
            try
            {
                List<IQLabValue> cosArgs = new List<IQLabValue>();
                cosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> cosRes = new List<IQLabValue>();
                cosRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5.4396, -8.4298), new QFloat64(-1.5656, -3.2979) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(cosRes, Helper.roundListTo4Decimals(f.cos(cosArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            #endregion

            #region Sin
            //treba da vrati exception jer mu je prosledjen boolean
            try
            {
                List<IQLabValue> sinArgs = new List<IQLabValue>();
                sinArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> acosRes = f.sin(sinArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> sinArgs = new List<IQLabValue>();
                sinArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> sinRes = new List<IQLabValue>();
                sinRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(8.4716, 5.4127), new QFloat64(3.421, -1.5093) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(sinRes,Helper.roundListTo4Decimals( f.sin(sinArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            #region Tan
            //treba da vrati exception jer mu nije prosledjen nijedan argument
            try
            {
                List<IQLabValue> tanArgs = new List<IQLabValue>();
                List<IQLabValue> tanRes = f.tan(tanArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> tanArgs = new List<IQLabValue>();
                tanArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> tanRes = new List<IQLabValue>();
                tanRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.0045, 1.0021), new QFloat64(-0.0284, 1.0238) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(tanRes,Helper.roundListTo4Decimals( f.tan(tanArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion


            #region Cosh
            //treba da vrati exception jer su mu prosledjena 2 argumenta
            try
            {
                List<IQLabValue> coshArgs = new List<IQLabValue>();
                coshArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                coshArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                List<IQLabValue> acoshRes = f.cosh(coshArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> coshArgs = new List<IQLabValue>();
                coshArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> coshRes = new List<IQLabValue>();
                coshRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.5276, 0.1658), new QFloat64(-1.5656, 3.2979) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(coshRes, Helper.roundListTo4Decimals(f.cosh(coshArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            #region Sinh
            //treba da vrati exception jer mu je prosledjen char
            try
            {
                List<IQLabValue> sinhArgs = new List<IQLabValue>();
                sinhArgs.Add(new QCharNDimArray(new QChar[] { new QChar('r') }, new int[] { 1, 1 }));
                List<IQLabValue> sinhRes = f.sinh(sinhArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> sinhArgs = new List<IQLabValue>();
                sinhArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> sinhRes = new List<IQLabValue>();
                sinhRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.1634, 0.2178), new QFloat64(-1.5093, 3.4210) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(sinhRes,Helper.roundListTo4Decimals( f.sinh(sinhArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            #region Tanh
            //treba da vrati exception jer mu je prosledjen int64
            try
            {
                List<IQLabValue> tanhArgs = new List<IQLabValue>();
                tanhArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(15,3) }, new int[] { 1, 1 }));
                List<IQLabValue> tanhRes = f.tanh(tanhArgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer
            try
            {
                List<IQLabValue> tanhArgs = new List<IQLabValue>();
                tanhArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 3), new QFloat64(2, 2) }, new int[] { 2, 1 }));
                List<IQLabValue> tanhRes = new List<IQLabValue>();
                tanhRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.768, -0.0592), new QFloat64(1.0238, -0.0284) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(tanhRes, Helper.roundListTo4Decimals(f.tanh(tanhArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            #endregion

            #region Bitcmp
            //prosledimo neki element i vrati se greska
            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                bitAndArgs.Add(new QInt32NDimArray(new QInt32[] { new QInt32(13) }, new int[] { 1, 1 }));
                bitAndArgs.Add(new QInt32NDimArray(new QInt32[] { new QInt32(4) }, new int[] { 1, 1 }));

                List<IQLabValue> bitAndRes = f.bitcmp(bitAndArgs);

                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            #endregion

            #region Bitmax
            //prosledimo neki element i vrati se greska
            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                bitAndArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(15) }, new int[] { 1, 1 }));
                
                List<IQLabValue> bitAndRes = f.bitmax(bitAndArgs);

                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                List<IQLabValue> bitAndRes = new List<IQLabValue>();

                bitAndRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(9007199254740992) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(bitAndRes, f.bitmax(bitAndArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Bitand
            //prosledice mu chr i int64, treba da javi gresku
            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                bitAndArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(15)}, new int[] { 1, 1 }));
                bitAndArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, new int[] { 1, 1 }));
                List<IQLabValue> bitAndRes = f.bitand(bitAndArgs);
                Assert.AreEqual(true, false);

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            //prosledicu kompleksni treba da javi izuzetak
            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                bitAndArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(15,6) }, new int[] { 1, 1 }));
                bitAndArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(15, 6) }, new int[] { 1, 1 }));
                List<IQLabValue> bitAndRes = f.bitand(bitAndArgs);
                Assert.AreEqual(true, false);

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //prosledicu double
            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                bitAndArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(15) }, new int[] { 1, 1 }));
                bitAndArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(15) }, new int[] { 1, 1 }));
                List<IQLabValue> bitAndRes = f.bitand(bitAndArgs);
                Assert.AreEqual(true, false);

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //obican primer sa skalarom
            try
            {
                List<IQLabValue> bitAndArgs = new List<IQLabValue>();
                bitAndArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(13), new QUInt64(13) }, new int[] { 2, 1 }));
                bitAndArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(27) }, new int[] { 1, 1 }));
                List<IQLabValue> bitAndRes = new List<IQLabValue>();
                bitAndRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(9), new QFloat64(9) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(bitAndRes, f.bitand(bitAndArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            #endregion

            #region Bitor
            //obican primer sa skalarom
            try
            {
                List<IQLabValue> bitOrArgs = new List<IQLabValue>();
                bitOrArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(13), new QUInt64(13) }, new int[] { 2, 1 }));
                bitOrArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(27), new QUInt64(37) }, new int[] { 2, 1 }));
                List<IQLabValue> bitOrRes = new List<IQLabValue>();
                bitOrRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(31), new QFloat64(45) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(bitOrRes, f.bitor(bitOrArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Bitxor
            try
            {
                List<IQLabValue> bitXorArgs = new List<IQLabValue>();
                bitXorArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(13), new QUInt64(13) }, new int[] { 2, 1 }));
                bitXorArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(27), new QUInt64(37) }, new int[] { 2, 1 }));
                List<IQLabValue> bitXorRes = new List<IQLabValue>();
                bitXorRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(22), new QFloat64(40) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(bitXorRes, f.bitxor(bitXorArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion



            #region Ceil

            try
            {
                List<IQLabValue> ceilArgs = new List<IQLabValue>();
                ceilArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.9), new QFloat64(-0.2),
                                 new QFloat64(3.4),  new QFloat64(5.6) ,  new QFloat64(7.0),  new QFloat64(2.4,3.6)}, new int[] { 6, 1 }));
                
                List<IQLabValue> ceilRes = new List<IQLabValue>();
                ceilRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1), new QFloat64(0),
                                 new QFloat64(4),  new QFloat64(6) ,  new QFloat64(7.0),  new QFloat64(3,4)}, new int[] { 6, 1 }));
                
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ceilRes, f.ceil(ceilArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Floor

            try
            {
                List<IQLabValue> floorArgs = new List<IQLabValue>();
                floorArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.9), new QFloat64(-0.2),
                                 new QFloat64(3.4),  new QFloat64(5.6) ,  new QFloat64(7.0),  new QFloat64(2.4,3.6)}, new int[] { 6, 1 }));

                List<IQLabValue> floorRes = new List<IQLabValue>();
                floorRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-2), new QFloat64(-1),
                                 new QFloat64(3),  new QFloat64(5) ,  new QFloat64(7.0),  new QFloat64(2,3)}, new int[] { 6, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(floorRes,f.floor(floorArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Round

            try
            {
                List<IQLabValue> roundArgs = new List<IQLabValue>();
                roundArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.9), new QFloat64(-0.2),
                                 new QFloat64(3.4),  new QFloat64(5.6) ,  new QFloat64(7.0),  new QFloat64(2.4,3.6), new QFloat64(2.5)}, new int[] { 7, 1 }));

                List<IQLabValue> roundRes = new List<IQLabValue>();
                roundRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-2), new QFloat64(0),
                                 new QFloat64(3),  new QFloat64(6) ,  new QFloat64(7.0),  new QFloat64(2,4), new QFloat64(3)}, new int[] { 7, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(roundRes, f.round(roundArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Fix

            try
            {
                List<IQLabValue> fixArgs = new List<IQLabValue>();
                fixArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.9), new QFloat64(-0.2),
                                 new QFloat64(3.4),  new QFloat64(5.6) ,  new QFloat64(7.0),  new QFloat64(2.4,3.6), new QFloat64(2.5)}, new int[] { 7, 1 }));

                List<IQLabValue> fixRes = new List<IQLabValue>();
                fixRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1), new QFloat64(0),
                                 new QFloat64(3),  new QFloat64(5) ,  new QFloat64(7.0),  new QFloat64(2,3), new QFloat64(2)}, new int[] { 7, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(fixRes, f.fix(fixArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion




            #region Complex
            //pokusacu razlicite tipove
            try
            {
                List<IQLabValue> comArgs = new List<IQLabValue>();
                comArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(2) }, new int[] { 2, 1 }));
                comArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(5) }, new int[] { 2, 1 }));

                List<IQLabValue> res = f.complex(comArgs);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //pravi primer
            try
            {
                List<IQLabValue> comArgs = new List<IQLabValue>();
                comArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3), new QInt64(2) }, new int[] { 2, 1 }));
                comArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(5) }, new int[] { 2, 1 }));

                List<IQLabValue> comRes = new List<IQLabValue>();
                comRes.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3,1), new QInt64(2,5) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(comRes, f.complex(comArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //isto to samo uint
            try
            {
                List<IQLabValue> comArgs = new List<IQLabValue>();
                comArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(3), new QUInt64(2) }, new int[] { 2, 1 }));
                comArgs.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(5) }, new int[] { 2, 1 }));

                List<IQLabValue> comRes = new List<IQLabValue>();
                comRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(3, 1), new QUInt64(2, 5) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(comRes, f.complex(comArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Conj
            try
            {
                List<IQLabValue> conjArgs = new List<IQLabValue>();
                conjArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1,2), new QFloat64(3,5), new QFloat64(4) }, new int[] { 3, 1 }));

                List<IQLabValue> conjRes = new List<IQLabValue>();
                conjRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, -2), new QFloat64(3, -5), new QFloat64(4) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(conjRes, f.conj(conjArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Real
            try
            {
                List<IQLabValue> realArgs = new List<IQLabValue>();
                realArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 2), new QFloat64(3, 5), new QFloat64(4) }, new int[] { 3, 1 }));

                List<IQLabValue> realRes = new List<IQLabValue>();
                realRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3), new QFloat64(4) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(realRes, f.real(realArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Imag
            try
            {
                List<IQLabValue> imagArgs = new List<IQLabValue>();
                imagArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, 2), new QFloat64(3, 5), new QFloat64(4) }, new int[] { 3, 1 }));

                List<IQLabValue> imagRes = new List<IQLabValue>();
                imagRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(5), new QFloat64(0) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(imagRes, f.imag(imagArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Exp
            try
            {
                List<IQLabValue> expArgs = new List<IQLabValue>();
                expArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1,3)}, new int[] { 2, 1 }));

                List<IQLabValue> expRes = new List<IQLabValue>();
                expRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7.3891), new QFloat64(-2.6911,0.3836) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(expRes,Helper.roundListTo4Decimals( f.exp(expArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Log
            try
            {
                List<IQLabValue> logArgs = new List<IQLabValue>();
                logArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1, 3) }, new int[] { 2, 1 }));

                List<IQLabValue> logRes = new List<IQLabValue>();
                logRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.6931), new QFloat64(1.1513, 1.2490) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(logRes, Helper.roundListTo4Decimals(f.log(logArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Log2
            try
            {
                List<IQLabValue> log2Args = new List<IQLabValue>();
                log2Args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(5, 3), new QFloat64(1, 3) }, new int[] { 3, 1 }));

                List<IQLabValue> log2Res = new List<IQLabValue>();
                log2Res.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1),new QFloat64(2.5437, 0.7797), new QFloat64(1.6610, 1.8020) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(log2Res, Helper.roundListTo4Decimals(f.log2(log2Args))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Ischar
            try
            {
                List<IQLabValue> ischArgs = new List<IQLabValue>();
                ischArgs.Add(new QCharNDimArray(new QChar[]{new QChar('d'), new QChar('b')}, new int[]{2,1}));

                List<IQLabValue> ischRes = new List<IQLabValue>();
                ischRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ischRes, f.ischar(ischArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> ischArgs = new List<IQLabValue>();
                ischArgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                List<IQLabValue> ischRes = new List<IQLabValue>();
                ischRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ischRes, f.ischar(ischArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Isempty
            try
            {
                List<IQLabValue> isemARgs = new List<IQLabValue>();
                isemARgs.Add(new QBooleanNDimArray(new int[] { 1, 2, 3, 4, 0, 89 }));

                List<IQLabValue> isemRes = new List<IQLabValue>();
                isemRes.Add(new QBooleanNDimArray(new QBoolean[]{ new QBoolean(true)}, new int[]{1,1}));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isemRes, f.isempty(isemARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Isfinite
            try
            {
                List<IQLabValue> isfinArgs = new List<IQLabValue>();
                isfinArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity,3), 
                            new QFloat64(double.NaN,3), new QFloat64(4), new QFloat64(4, double.NaN)}, new int[]{4,1}));

                List<IQLabValue> isfinRes = new List<IQLabValue>();
                isfinRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false),
                            new QBoolean(true),new QBoolean(false)}, new int[] { 4, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isfinRes, f.isfinite(isfinArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Isfloat
            try
            {
                List<IQLabValue> isfloatArgs = new List<IQLabValue>();
                isfloatArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity,3), 
                            new QFloat64(double.NaN,3), new QFloat64(4), new QFloat64(4, double.NaN)}, new int[] { 4, 1 }));

                List<IQLabValue> isfloatRes = new List<IQLabValue>();
                isfloatRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true)}, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isfloatRes, f.isfloat(isfloatArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> isfloatArgs = new List<IQLabValue>();
                isfloatArgs.Add(new QCharNDimArray(new QChar[]{new QChar('a')}, new int[] { 1, 1 }));

                List<IQLabValue> isfloatRes = new List<IQLabValue>();
                isfloatRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isfloatRes, f.isfloat(isfloatArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Isinf
            try
            {
                List<IQLabValue> isinfArgs = new List<IQLabValue>();
                isinfArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity,3), 
                            new QFloat64(double.NaN,3), new QFloat64(4), new QFloat64(4, double.NegativeInfinity)}, new int[] { 4, 1 }));

                List<IQLabValue> isinfRes = new List<IQLabValue>();
                isinfRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false),
                            new QBoolean(false),new QBoolean(true)}, new int[] { 4, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isinfRes, f.isinf(isinfArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Isinteger
            try
            {
                List<IQLabValue> isintArgs = new List<IQLabValue>();
                isintArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity,3), 
                            new QFloat64(double.NaN,3), new QFloat64(4), new QFloat64(4, double.NaN)}, new int[] { 4, 1 }));

                List<IQLabValue> isintRes = new List<IQLabValue>();
                isintRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false)}, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isintRes, f.isinteger(isintArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> isintArgs = new List<IQLabValue>();
                isintArgs.Add(new QInt64NDimArray(new QInt64[]{new QInt64(4,5)}, new int[]{1,1}));

                List<IQLabValue> isintRes = new List<IQLabValue>();
                isintRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isintRes, f.isinteger(isintArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Isletter
            try
            {
                List<IQLabValue> ilArgs = new List<IQLabValue>();
                ilArgs.Add(new QCharNDimArray(new QChar[] { new QChar('1'), new QChar('a'), new QChar(','), new QChar('S') }, new int[] {4,1 }));


                List<IQLabValue> ilRes = new List<IQLabValue>();
                ilRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false), new QBoolean(true) }, new int[] { 4, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ilRes, f.isletter(ilArgs)));
           
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion


            #region Islogical
            try
            {
                List<IQLabValue> islogArgs = new List<IQLabValue>();
                islogArgs.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('b') }, new int[] { 2, 1 }));

                List<IQLabValue> islogRes = new List<IQLabValue>();
                islogRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(islogRes, f.islogical(islogArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> islogARgs = new List<IQLabValue>();
                islogARgs.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                List<IQLabValue> islogRes = new List<IQLabValue>();
                islogRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(islogRes, f.islogical(islogARgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Isnan
            try
            {
                List<IQLabValue> isnanArgs = new List<IQLabValue>();
                isnanArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity,3), 
                            new QFloat64(double.NaN,3), new QFloat64(4), new QFloat64(4, double.NaN)}, new int[] { 4, 1 }));

                List<IQLabValue> isnanRes = new List<IQLabValue>();
                isnanRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true),
                            new QBoolean(false),new QBoolean(true)}, new int[] { 4, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isnanRes, f.isnan(isnanArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Isnumeric
            try
            {
                List<IQLabValue> isnumArgs = new List<IQLabValue>();
                isnumArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(double.PositiveInfinity,3), 
                            new QFloat64(double.NaN,3), new QFloat64(4), new QFloat64(4, double.NaN)}, new int[] { 4, 1 }));

                List<IQLabValue> isnumRes = new List<IQLabValue>();
                isnumRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isnumRes, f.isnumeric(isnumArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> isnumArgs = new List<IQLabValue>();
                isnumArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, new int[] { 1, 1 }));

                List<IQLabValue> isnumRes = new List<IQLabValue>();
                isnumRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isnumRes, f.isnumeric(isnumArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Isreal
            
            try
            {
                List<IQLabValue> isrealArgs = new List<IQLabValue>();
                isrealArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(3), 
                            new QFloat64(1,3), new QFloat64(4), new QFloat64(4, 0)}, new int[] { 4, 1 }));

                List<IQLabValue> isrealRes = new List<IQLabValue>();
                isrealRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isrealRes, f.isreal(isrealArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> isrealArgs = new List<IQLabValue>();
                isrealArgs.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(3), 
                            new QFloat64(1), new QFloat64(4), new QFloat64(4, 0)}, new int[] { 4, 1 }));

                List<IQLabValue> isrealRes = new List<IQLabValue>();
                isrealRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isrealRes, f.isreal(isrealArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Isspace
            try
            {
                List<IQLabValue> isArgs = new List<IQLabValue>();
                isArgs.Add(new QCharNDimArray(new QChar[] { new QChar(' '), new QChar('\t'), new QChar(','), new QChar('S') }, new int[] { 4, 1 }));


                List<IQLabValue> isRes = new List<IQLabValue>();
                isRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(false), new QBoolean(false) }, new int[] { 4, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(isRes, f.isspace(isArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Mod
            try
            {
                List<IQLabValue> modArgs = new List<IQLabValue>();
                modArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7.2), new QFloat64(78), new QFloat64(36), new QFloat64(42.5) }, new int[] {2,2 }));
                modArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(6), new QFloat64(5), new QFloat64(7), new QFloat64(8) }, new int[] { 2, 2 }));
               


                List<IQLabValue> modRes = new List<IQLabValue>();
                modRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.2), new QFloat64(3), new QFloat64(1), new QFloat64(2.5) }, new int[] {2,2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(modRes, Helper.roundListTo4Decimals(f.mod(modArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> modArgs = new List<IQLabValue>();
                modArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7), new QFloat64(8), new QFloat64(9), new QFloat64(42.5) }, new int[] { 2, 2 }));
                modArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7), new QFloat64(0), new QFloat64(-4), new QFloat64(8) }, new int[] { 2, 2 }));



                List<IQLabValue> modRes = new List<IQLabValue>();
                modRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(8), new QFloat64(-3), new QFloat64(2.5) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(modRes, Helper.roundListTo4Decimals(f.mod(modArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> modArgs = new List<IQLabValue>();
                modArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(414), new QFloat64(-1567), new QFloat64(-3333), new QFloat64(798) }, new int[] { 2, 2 }));
                modArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-29), new QFloat64(48), new QFloat64(-17), new QFloat64(23) }, new int[] { 2, 2 }));



                List<IQLabValue> modRes = new List<IQLabValue>();
                modRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-21), new QFloat64(17), new QFloat64(-1), new QFloat64(16) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(modRes, Helper.roundListTo4Decimals(f.mod(modArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Ndims
            try
            {
                List<IQLabValue> ndimsArgs = new List<IQLabValue>();
                ndimsArgs.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(3), new QFloat64(3), new QFloat64(3), new QFloat64(3),
                    new QFloat64(3),new QFloat64(3),new QFloat64(3),new QFloat64(3)},new int[] { 2, 2, 2 }));


                List<IQLabValue> ndimsRes = new List<IQLabValue>();
                ndimsRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3)}, new int[] { 1, 1 }));


                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(ndimsRes, f.ndims(ndimsArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Nnz
            try
            {
                List<IQLabValue> nnzArgs = new List<IQLabValue>();
                nnzArgs.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(0), new QFloat64(3), new QFloat64(3), new QFloat64(3),
                    new QFloat64(3),new QFloat64(0),new QFloat64(0),new QFloat64(3)}, new int[] { 2, 2, 2 }));


                List<IQLabValue> nnzRes = new List<IQLabValue>();
                nnzRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, new int[] { 1, 1 }));


                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(nnzRes, f.nnz(nnzArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Pow2
            //sa jednim argumentom
            try
            {
                List<IQLabValue> pow2Args = new List<IQLabValue>();
                pow2Args.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(0), new QFloat64(3), new QFloat64(10), new QFloat64(5,6)}, new int[] { 2, 2 }));


                List<IQLabValue> pow2Res = new List<IQLabValue>();
                pow2Res.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(8), new QFloat64(1024), new QFloat64(-16.8215, - 27.2220) }, new int[] { 2, 2 }));


                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(pow2Res, Helper.roundListTo4Decimals( f.pow2(pow2Args))));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //sa dva argumenta
            try
            {
                List<IQLabValue> pow2Args = new List<IQLabValue>();
                pow2Args.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(2,3)}, new int[] { 1, 1 }));
                pow2Args.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(4,5)}, new int[] { 1, 1 }));


                List<IQLabValue> pow2Res = new List<IQLabValue>();
                pow2Res.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(32) }, new int[] { 1,1 }));


                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(pow2Res, Helper.roundListTo4Decimals( f.pow2(pow2Args))));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Power
            try
            {
                List<IQLabValue> powArgs = new List<IQLabValue>();
                powArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1,2), new QFloat64(3,4)}, new int[] { 2, 1 }));
                powArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5,6), new QFloat64(7,8) }, new int[] { 2, 1 }));

                List<IQLabValue> powRes = new List<IQLabValue>();
                powRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-0.0430, -0.0588), new QFloat64(40.7573 , 23.1748) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(powRes, Helper.roundListTo4Decimals(f.power(powArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Reallog
            try
            {
                List<IQLabValue> reallogArgs = new List<IQLabValue>();
                reallogArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2), new QFloat64(3.4), new QFloat64(19) }, new int[] { 3, 1 }));

                List<IQLabValue> reallogRes = new List<IQLabValue>();
                reallogRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.6094), new QFloat64(1.2238), new QFloat64(2.9444) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(reallogRes, Helper.roundListTo4Decimals(f.reallog(reallogArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //proba sa negativnim
            try
            {
                List<IQLabValue> reallogArgs = new List<IQLabValue>();
                reallogArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-0.2), new QFloat64(3.4), new QFloat64(19) }, new int[] { 3, 1 }));

                List<IQLabValue> reallogRes = f.reallog(reallogArgs);
                Assert.AreEqual(true, false);
                
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }


            #endregion


            #region Realpow
            try
            {
                List<IQLabValue> realpowArgs = new List<IQLabValue>();
                realpowArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(15), new QFloat64(3) }, new int[] { 2, 1 }));
                realpowArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, new int[] { 1, 1 }));


                List<IQLabValue> realpowRes = new List<IQLabValue>();
                realpowRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3375), new QFloat64(27) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(realpowRes, Helper.roundListTo4Decimals(f.realpow(realpowArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //proba sa negativnim 
            /*
            try
            {
                List<IQLabValue> realpowArgs = new List<IQLabValue>();
                realpowArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-0.2, 5), new QFloat64(3.4), new QFloat64(19) }, new int[] { 3, 1 }));

                List<IQLabValue> realpowRes = f.realpow(realpowArgs);
                Assert.AreEqual(true, false);

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            */
            #endregion

            #region Realsqrt
            try
            {
                List<IQLabValue> realsqrtArgs = new List<IQLabValue>();
                realsqrtArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2), new QFloat64(3.4), new QFloat64(19) }, new int[] { 3, 1 }));

                List<IQLabValue> realsqrtRes = new List<IQLabValue>();
                realsqrtRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.4472), new QFloat64(1.8439), new QFloat64(4.3589) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(realsqrtRes, Helper.roundListTo4Decimals(f.realsqrt(realsqrtArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
         
            #endregion


            #region Rem
            try
            {
                List<IQLabValue> remArgs = new List<IQLabValue>();
                remArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7), new QFloat64(8), new QFloat64(9), new QFloat64(42.5) }, new int[] { 2, 2 }));
                remArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7), new QFloat64(0), new QFloat64(-4), new QFloat64(8) }, new int[] { 2, 2 }));



                List<IQLabValue> remRes = new List<IQLabValue>();
                remRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(double.NaN), new QFloat64(1), new QFloat64(2.5) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(remRes, Helper.roundListTo4Decimals(f.rem(remArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            
            try
            {
                List<IQLabValue> remArgs = new List<IQLabValue>();
                remArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(414), new QFloat64(-1567), new QFloat64(-3333), new QFloat64(798) }, new int[] { 2, 2 }));
                remArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-29), new QFloat64(48), new QFloat64(-17), new QFloat64(23) }, new int[] { 2, 2 }));



                List<IQLabValue> remRes = new List<IQLabValue>();
                remRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(8), new QFloat64(-31), new QFloat64(-1), new QFloat64(16) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(remRes, Helper.roundListTo4Decimals(f.rem(remArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
              
            #endregion


            #region Sign
            try
            {
                List<IQLabValue> signArgs = new List<IQLabValue>();
                signArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1,5), new QFloat64(-3), new QFloat64(0,4), new QFloat64(2) }, new int[] { 2, 2 }));
                
                List<IQLabValue> signRes = new List<IQLabValue>();
                signRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.1961, 0.9806), new QFloat64(-1), new QFloat64(0,1), new QFloat64(1) }, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(signRes, Helper.roundListTo4Decimals(f.sign(signArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
              
            #endregion

            #region Sqrt
            try
            {
                List<IQLabValue> sqrtArgs = new List<IQLabValue>();
                sqrtArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2,5), new QFloat64(1, 3) }, new int[] { 2, 1 }));

                List<IQLabValue> sqrtRes = new List<IQLabValue>();
                sqrtRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.9216, 1.3010), new QFloat64(1.4426 , 1.0398) }, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(sqrtRes, Helper.roundListTo4Decimals(f.sqrt(sqrtArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Deblank
            /*
            try
            {
                List<IQLabValue> dbArgs = new List<IQLabValue>();
                dbArgs.Add(new QCharNDimArray(new QChar[]{ new QChar('f'), new QChar('d'), new QChar('h'), new QChar('p'),
                             new QChar('l'), new QChar('a'), new QChar('e'), new QChar('l'),
                             new QChar('a'), new QChar('r'), new QChar('l'), new QChar(' '),
                             new QChar('s'), new QChar(' '), new QChar('p'), new QChar(' '),
                             new QChar('a'), new QChar(' '), new QChar(' '), new QChar(' ')}, new int[] { 4, 5 }));

                List<IQLabValue> dbRes = new List<IQLabValue>();
                dbRes.Add(new QCharNDimArray(new QChar[]{ new QChar('f'), new QChar('d'), new QChar('h'), new QChar('p'),
                             new QChar('l'), new QChar('a'), new QChar('e'), new QChar('l'),
                             new QChar('a'), new QChar('r'), new QChar('l'), new QChar('\0'),
                             new QChar('s'), new QChar('\0'), new QChar('p'), new QChar('\0'),
                             new QChar('a'), new QChar('\0'), new QChar('\0'), new QChar('\0')}, new int[] { 4, 5 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(dbRes, f.deblank(dbArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            */ 
            //NAPOMENA: prijavljuje gresku jer u areIQLabValuesListEaqual koristimo areIQLabValuesEaqual
            //a on sve pretvara u QFloat64NdimArray. QFloat64 konstruktor javlja gresku jer mu je prosledjena '\0'
            // sto  on vidi kao null vrednost, a to ponasanje nije podrzano
            #endregion

            #region Findstr
            try
            {
                List<IQLabValue> fsArgs = new List<IQLabValue>();
                fsArgs.Add(new QCharNDimArray(
                    new QChar[]{new QChar('m'), new QChar('a'), new QChar('l'),new QChar('i'),new QChar(' '),
                    new QChar('m'), new QChar('o'), new QChar('k'), new QChar('r'), new QChar('i'), new QChar(' '),
                    new QChar('l'), new QChar('u'), new QChar('g')
                    }, new int[] { 1, 14 }));
                fsArgs.Add(new QCharNDimArray(new QChar[] { new QChar('l'), new QChar('u'), new QChar('g') }, new int[] { 1, 3 }));

                List<IQLabValue> fsRes = new List<IQLabValue>();
                fsRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(12) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(fsRes, f.findstr(fsArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //
            try
            {
                List<IQLabValue> fsArgs = new List<IQLabValue>();
                fsArgs.Add(new QCharNDimArray(
                    new QChar[]{new QChar('m'), new QChar('a'), new QChar('l'),new QChar('i'),new QChar(' '),
                    new QChar('m'), new QChar('a'), new QChar('l'), new QChar('i'),  new QChar(' '),
                    new QChar('l'), new QChar('u'), new QChar('g')
                    }, new int[] { 1, 13 }));
                fsArgs.Add(new QCharNDimArray(new QChar[] { new QChar('m'), new QChar('a'), new QChar('l'), new QChar('i') }, new int[] { 1, 4 }));

                List<IQLabValue> fsRes = new List<IQLabValue>();
                fsRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(6) }, new int[] { 1, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(fsRes, f.findstr(fsArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            
            #region Lower
            
            
            try
            {
                List<IQLabValue> lowerARgs = new List<IQLabValue>();
                lowerARgs.Add(new QCell(new IQLabValue[]{new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('Y'), new QChar(' '),
                            new QChar('B'),new QChar('.')}, new int[] { 1, 5 })}, new int[] { 1, 1 }));

                List<IQLabValue> lowerRes = new List<IQLabValue>();
                lowerRes.Add(new QCell(new IQLabValue[]{new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('y'), new QChar(' '),
                            new QChar('b'),new QChar('.')}, new int[] { 1, 5 })}, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(lowerRes, f.lower(lowerARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> lowerARgs = new List<IQLabValue>();
                lowerARgs.Add(new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('y'), new QChar(' '),
                            new QChar('B'),new QChar('.')}, new int[] { 1, 5 }));

                List<IQLabValue> lowerRes = new List<IQLabValue>();
                lowerRes.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('y'), new QChar(' '),
                            new QChar('b'),new QChar('.')}, new int[] { 1, 5 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(lowerRes, f.lower(lowerARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Uper
            try
            {
                List<IQLabValue> uperARgs = new List<IQLabValue>();
                uperARgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('Y'), new QChar(' '),
                            new QChar('b'),new QChar('.')}, new int[] { 1, 5 }));

                List<IQLabValue> uperRes = new List<IQLabValue>();
                uperRes.Add(new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('Y'), new QChar(' '),
                            new QChar('B'),new QChar('.')}, new int[] { 1, 5 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(uperRes, f.uper(uperARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            

            
            try
            {
                List<IQLabValue> uperARgs = new List<IQLabValue>();
                uperARgs.Add(new QCell(new IQLabValue[]{new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('y'), new QChar(' '),
                            new QChar('b'),new QChar('.')}, new int[] { 1, 5 })}, new int[] { 1, 1 }));

                List<IQLabValue> uperRes = new List<IQLabValue>();
                uperRes.Add(new QCell(new IQLabValue[]{new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('Y'), new QChar(' '),
                            new QChar('B'),new QChar('.')}, new int[] { 1, 5 })}, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(uperRes, f.uper(uperARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Strrep
            try
            {
                List<IQLabValue> srArgs = new List<IQLabValue>();
                srArgs.Add(new QCharNDimArray(new QChar[] { new QChar('k'), new QChar('u'), new QChar('c'),
                new QChar('i'), new QChar('c'), new QChar('a')}, new int[] { 1, 6 }));

                srArgs.Add(new QCharNDimArray(new QChar[] {new QChar('i'), new QChar('c'), new QChar('a')}, new int[] { 1, 3 }));
                srArgs.Add(new QCharNDimArray(new QChar[] {  new QChar('a')}, new int[] { 1, 1 }));

                List<IQLabValue> srRes = new List<IQLabValue>();
                srRes.Add(new QCharNDimArray(new QChar[] { new QChar('k'), new QChar('u'), new QChar('c'),new QChar('a')}, new int[] { 1, 4 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(srRes, f.strrep(srArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }



            try
            {
                List<IQLabValue> srARgs = new List<IQLabValue>();
                srARgs.Add(new QCell(new IQLabValue[]{new QCharNDimArray(new QChar[] { new QChar('k'), new QChar('u'), new QChar('c'),
                            new QChar('i'),new QChar('c'), new QChar('a')}, new int[] { 1, 6 }),
                new QCharNDimArray(new QChar[] { new QChar('k'), new QChar('a'), new QChar('m'),
                            new QChar('i'),new QChar('l'), new QChar('i'), new QChar('c'), new QChar('a')}, new int[] { 1, 8 })}, new int[] { 2, 1 }));

                srARgs.Add(new QCharNDimArray(new QChar[] { new QChar('i'), new QChar('c'), new QChar('a') }, new int[] { 1, 3 }));
                srARgs.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, new int[] { 1, 1 }));

                List<IQLabValue> srRes = new List<IQLabValue>();
                srRes.Add(new QCell(new IQLabValue[]{new QCharNDimArray(new QChar[] { new QChar('k'), new QChar('u'), new QChar('c'),
                             new QChar('a')}, new int[] { 1, 4 }),
                new QCharNDimArray(new QChar[] { new QChar('k'), new QChar('a'), new QChar('m'),
                            new QChar('i'),new QChar('l'), new QChar('a')}, new int[] { 1, 6 })}, new int[] { 2, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(srRes, f.strrep(srARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Strcmp
            //dva chara
            try
            {
                List<IQLabValue> scArgs = new List<IQLabValue>();
                scArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }));
                scArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }));

                List<IQLabValue> scRes = new List<IQLabValue>();
                scRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(scRes, f.strcmp(scArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //char i cell
            try
            {
                List<IQLabValue> scArgs = new List<IQLabValue>();
                scArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }));
                scArgs.Add(new QCell(new IQLabValue[] { 
                    new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }),
                    new QInt64NDimArray(new QInt64[]{new QInt64(15)}, new int[]{1,1}),
                    new QCharNDimArray(new QChar[] { new QChar('s'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 })
                       }, new int[] { 3, 1 }));

                List<IQLabValue> scRes = new List<IQLabValue>();
                scRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(false) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(scRes, f.strcmp(scArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            //dva cella
            try
            {
                List<IQLabValue> scArgs = new List<IQLabValue>();
                
                scArgs.Add(new QCell(new IQLabValue[] { 
                    new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }),
                    new QInt64NDimArray(new QInt64[]{new QInt64(15)}, new int[]{1,1}),
                    new QCharNDimArray(new QChar[] { new QChar('s'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 })
                       }, new int[] { 3, 1 }));
                scArgs.Add(new QCell(new IQLabValue[] { 
                    new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }),
                    new QInt64NDimArray(new QInt64[]{new QInt64(15)}, new int[]{1,1}),
                    new QCharNDimArray(new QChar[] { new QChar('s'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 })
                       }, new int[] { 3, 1 }));

                List<IQLabValue> scRes = new List<IQLabValue>();
                scRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(scRes, f.strcmp(scArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }



            #endregion



            #region Strcmpi
            //dva chara
            try
            {
                List<IQLabValue> sciArgs = new List<IQLabValue>();
                sciArgs.Add(new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('c'), new QChar('B') }, new int[] { 3, 1 }));
                sciArgs.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }));

                List<IQLabValue> sciRes = new List<IQLabValue>();
                sciRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(sciRes, f.strcmpi(sciArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            //char i cell
            try
            {
                List<IQLabValue> sciArgs = new List<IQLabValue>();
                sciArgs.Add(new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('c'), new QChar('B') }, new int[] { 3, 1 }));
                sciArgs.Add(new QCell(new IQLabValue[] { 
                    new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('C'), new QChar('b') }, new int[] { 3, 1 }),
                    new QInt64NDimArray(new QInt64[]{new QInt64(15)}, new int[]{1,1}),
                    new QCharNDimArray(new QChar[] { new QChar('s'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 })
                       }, new int[] { 3, 1 }));

                List<IQLabValue> sciRes = new List<IQLabValue>();
                sciRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(false) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(sciRes, f.strcmpi(sciArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            
            //dva cella
            try
            {
                List<IQLabValue> sciArgs = new List<IQLabValue>();

                sciArgs.Add(new QCell(new IQLabValue[] { 
                    new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }),
                    new QInt64NDimArray(new QInt64[]{new QInt64(15)}, new int[]{1,1}),
                    new QCharNDimArray(new QChar[] { new QChar('s'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 })
                       }, new int[] { 3, 1 }));
                sciArgs.Add(new QCell(new IQLabValue[] { 
                    new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b') }, new int[] { 3, 1 }),
                    new QInt64NDimArray(new QInt64[]{new QInt64(15)}, new int[]{1,1}),
                    new QCharNDimArray(new QChar[] { new QChar('S'), new QChar('C'), new QChar('b') }, new int[] { 3, 1 })
                       }, new int[] { 3, 1 }));

                List<IQLabValue> sciRes = new List<IQLabValue>();
                sciRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, new int[] { 3, 1 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(sciRes, f.strcmpi(sciArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            

            #endregion

            #region Atan2
            try
            {
                List<IQLabValue> a2Args = new List<IQLabValue>();
                a2Args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4) }, new int[] { 4, 1 }));
                a2Args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8) }, new int[] { 4, 1 }));

                List<IQLabValue> a2Res = new List<IQLabValue>();
                a2Res.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.1974), new QFloat64(0.3218), new QFloat64(0.4049), new QFloat64(0.4636) }, new int[] { 4, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(a2Res, Helper.roundListTo4Decimals(f.atan2(a2Args))));
            
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Hypot
            try
            {
                List<IQLabValue> hypotArgs = new List<IQLabValue>();
                hypotArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4) }, new int[] { 4, 1 }));
                hypotArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8) }, new int[] { 4, 1 }));

                List<IQLabValue> hypotRes = new List<IQLabValue>();
                hypotRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5.0990), new QFloat64(6.3246), new QFloat64(7.6158), new QFloat64(8.9443) }, new int[] { 4, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(hypotRes, Helper.roundListTo4Decimals(f.hypot(hypotArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> hypotArgs = new List<IQLabValue>();
                hypotArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.PositiveInfinity), new QFloat64(double.NaN), new QFloat64(double.PositiveInfinity, double.NegativeInfinity), new QFloat64(3,4) }, new int[] { 4, 1 }));
                hypotArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8) }, new int[] { 4, 1 }));

                List<IQLabValue> hypotRes = new List<IQLabValue>();
                hypotRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.PositiveInfinity), new QFloat64(double.NaN), new QFloat64(double.PositiveInfinity), new QFloat64(9.4340) }, new int[] { 4, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(hypotRes, Helper.roundListTo4Decimals(f.hypot(hypotArgs))));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region False
            try
            {
                List<IQLabValue> fArgs = new List<IQLabValue>();
                fArgs.Add(new QInt64NDimArray(new QInt64[]{new QInt64(2)}, new int[]{1,1}));

                List<IQLabValue> fRes = new List<IQLabValue>();
                fRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false),
                                    new QBoolean(false), new QBoolean(false)}, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(fRes, f.ffalse(fArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> fArgs = new List<IQLabValue>();
                fArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3), new QFloat64(2) }, new int[] { 1, 3 }));

                List<IQLabValue> fRes = new List<IQLabValue>();
                fRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false),new QBoolean(false), new QBoolean(false),
                                    new QBoolean(false), new QBoolean(false), new QBoolean(false), new QBoolean(false),
                                     new QBoolean(false), new QBoolean(false), new QBoolean(false), new QBoolean(false)}, new int[] { 2, 3, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(fRes, f.ffalse(fArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> fArgs = new List<IQLabValue>();
                fArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                fArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, new int[] { 1, 1 }));
                fArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));

                List<IQLabValue> fRes = new List<IQLabValue>();
                fRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false),new QBoolean(false), new QBoolean(false),
                                    new QBoolean(false), new QBoolean(false), new QBoolean(false), new QBoolean(false),
                                     new QBoolean(false), new QBoolean(false), new QBoolean(false), new QBoolean(false)}, new int[] { 2, 3, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(fRes, f.ffalse(fArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region True
            try
            {
                List<IQLabValue> tArgs = new List<IQLabValue>();
                tArgs.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, new int[] { 1, 1 }));

                List<IQLabValue> tRes = new List<IQLabValue>();
                tRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true),
                                    new QBoolean(true), new QBoolean(true)}, new int[] { 2, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(tRes, f.ttrue(tArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> tArgs = new List<IQLabValue>();
                tArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3), new QFloat64(2) }, new int[] { 1, 3 }));

                List<IQLabValue> tRes = new List<IQLabValue>();
                tRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true),new QBoolean(true), new QBoolean(true),
                                    new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true),
                                     new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true)}, new int[] { 2, 3, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(tRes, f.ttrue(tArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> tArgs = new List<IQLabValue>();
                tArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                tArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, new int[] { 1, 1 }));
                tArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));

                List<IQLabValue> tRes = new List<IQLabValue>();
                tRes.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true),new QBoolean(true), new QBoolean(true),
                                    new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true),
                                     new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true)}, new int[] { 2, 3, 2 }));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(tRes, f.ttrue(tArgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion


            #region Zeros
            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QCharNDimArray(new QChar[] { new QChar('i'), new QChar('n'), new QChar('t'), new QChar('6'), new QChar('4') }, new int[] {1,5 }));

                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));
            
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, new int[] { 1, 2 }));

                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0), new QFloat64(0),
                    new QFloat64(0), new QFloat64(0), new QFloat64(0) }, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));

                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0), new QFloat64(0),
                    new QFloat64(0) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                zerosArgs.Add(new QCharNDimArray(new QChar[] { new QChar('i'), new QChar('n'), new QChar('t'), new QChar('6'), new QChar('4') }, new int[] { 1, 5 }));


                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0),
                    new QInt64(0) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, new int[] { 1, 2 }));
                zerosArgs.Add(new QCharNDimArray(new QChar[] {new QChar('u'), new QChar('i'), new QChar('n'), new QChar('t'), new QChar('6'), new QChar('4') }, new int[] { 1, 6 }));


                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(0), new QUInt64(0), new QUInt64(0),
                    new QUInt64(0), new QUInt64(0), new QUInt64(0) }, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                zerosArgs.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('o'), new QChar('u'), new QChar('b'), new QChar('l'), new QChar('e') }, new int[] { 1, 6 }));


                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0), new QFloat64(0),
                    new QFloat64(0) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            try
            {
                List<IQLabValue> zerosArgs = new List<IQLabValue>();
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                zerosArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                

                List<IQLabValue> zerosRes = new List<IQLabValue>();
                zerosRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0), new QFloat64(0),new QFloat64(0), new QFloat64(0), new QFloat64(0),
                    new QFloat64(0), new QFloat64(0) }, new int[] { 2, 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(zerosRes, f.zeros(zerosArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion



            #region Ones
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QCharNDimArray(new QChar[] { new QChar('i'), new QChar('n'), new QChar('t'), new QChar('6'), new QChar('4') }, new int[] { 1, 5 }));

                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, new int[] { 1, 2 }));

                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(1), new QFloat64(1),
                    new QFloat64(1), new QFloat64(1), new QFloat64(1) }, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));

                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(1), new QFloat64(1),
                    new QFloat64(1) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                onesArgs.Add(new QCharNDimArray(new QChar[] { new QChar('i'), new QChar('n'), new QChar('t'), new QChar('6'), new QChar('4') }, new int[] { 1, 5 }));


                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1),
                    new QInt64(1) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, new int[] { 1, 2 }));
                onesArgs.Add(new QCharNDimArray(new QChar[] { new QChar('u'), new QChar('i'), new QChar('n'), new QChar('t'), new QChar('6'), new QChar('4') }, new int[] { 1, 6 }));


                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(1), new QUInt64(1),
                    new QUInt64(1), new QUInt64(1), new QUInt64(1) }, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                onesArgs.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('o'), new QChar('u'), new QChar('b'), new QChar('l'), new QChar('e') }, new int[] { 1, 6 }));


                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(1), new QFloat64(1),
                    new QFloat64(1) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            
            try
            {
                List<IQLabValue> onesArgs = new List<IQLabValue>();
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                onesArgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));


                List<IQLabValue> onesRes = new List<IQLabValue>();
                onesRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(1), new QFloat64(1),new QFloat64(1), new QFloat64(1), new QFloat64(1),
                    new QFloat64(1), new QFloat64(1) }, new int[] { 2, 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(onesRes, f.ones(onesArgs)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            
            #endregion


            #region Eye
            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3)}, new int[] { 1, 3 }));
                List<IQLabValue> eyeRes = f.eye(eyeARgs);
                Assert.AreEqual(true, false);
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }


            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] {  new QFloat64(2), new QFloat64(3) }, new int[] { 1, 2 }));
                List<IQLabValue> eyeRes = new List<IQLabValue>();
                eyeRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), 
                            new QFloat64(0), new QFloat64(1), new QFloat64(0), new QFloat64(0)}, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eyeRes, f.eye(eyeARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                List<IQLabValue> eyeRes = new List<IQLabValue>();
                eyeRes.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), 
                            new QFloat64(0), new QFloat64(1)}, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eyeRes, f.eye(eyeARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                eyeARgs.Add(new QCharNDimArray(new QChar[] { new QChar('u'), new QChar('i'),new QChar('n'),
                    new QChar('t'),new QChar('6'),new QChar('4')}, new int[] { 1, 6 }));

                List<IQLabValue> eyeRes = new List<IQLabValue>();
                eyeRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(0), new QUInt64(0), new QUInt64(1) }, new int[] { 2, 2 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eyeRes, f.eye(eyeARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QCharNDimArray(new QChar[] { new QChar('u'), new QChar('i'),new QChar('n'),
                    new QChar('t'),new QChar('6'),new QChar('4')}, new int[] { 1, 6 }));
                List<IQLabValue> eyeRes = new List<IQLabValue>();
                eyeRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eyeRes, f.eye(eyeARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, new int[] { 1, 2 }));
                eyeARgs.Add(new QCharNDimArray(new QChar[] { new QChar('u'), new QChar('i'),new QChar('n'),
                    new QChar('t'),new QChar('6'),new QChar('4')}, new int[] { 1, 6 }));

                List<IQLabValue> eyeRes = new List<IQLabValue>();
                eyeRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(0), new QUInt64(0), new QUInt64(1), new QUInt64(0), new QUInt64(0) }, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eyeRes, f.eye(eyeARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> eyeARgs = new List<IQLabValue>();
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, new int[] { 1, 1 }));
                eyeARgs.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, new int[] { 1, 1 }));
                eyeARgs.Add(new QCharNDimArray(new QChar[] { new QChar('u'), new QChar('i'),new QChar('n'),
                    new QChar('t'),new QChar('6'),new QChar('4')}, new int[] { 1, 6 }));

                List<IQLabValue> eyeRes = new List<IQLabValue>();
                eyeRes.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(0), new QUInt64(0), new QUInt64(1), new QUInt64(0), new QUInt64(0) }, new int[] { 2, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(eyeRes, f.eye(eyeARgs)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }


            #endregion


            #region Isequalwithequalnans
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, double.NaN), new QFloat64(2), new QFloat64(3), new QFloat64(4) }, 2, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1, double.NaN), new QFloat64(2), new QFloat64(3), new QFloat64(4) }, 2, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(65), new QInt64(66) }, 1, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('B') }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.0), new QFloat64(0.0) }, 1, 2));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(0.0) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(0.0) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray());
                args.Add(new QFloat64NDimArray());

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray());
                args.Add(new QFloat64NDimArray(1, 0, 3));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(1, 0, 3));
                args.Add(new QFloat64NDimArray(1, 0, 3));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequalwithequalnans(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Isequal
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(65), new QInt64(66) }, 1, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('A'), new QChar('B') }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.0), new QFloat64(0.0) }, 1, 2));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(0.0) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(0.0) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.isequal(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Issorted
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(4), new QInt64(3), new QInt64(2), new QInt64(1) }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(4) }, 2, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(5), new QInt64(3) }, 2, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(2), new QFloat64(9), new QFloat64(1) }, 1, 4));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('r'), new QChar('o'), new QChar('w'), new QChar('s') }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(2), new QFloat64(9), new QFloat64(1) }, 1, 4));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('t'), new QChar('d'), new QChar('i') }, 1, 3));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4), new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8) }, 2, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('r'), new QChar('o'), new QChar('w'), new QChar('s') }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('r'), new QChar('o'), new QChar('w'), new QChar('s') }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(2), new QFloat64(9), new QFloat64(1) }, 1, 4));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(2), new QFloat64(9), new QFloat64(1) }, 2, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            //TESTOVI SA NaN!!!
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(9), new QFloat64(double.NaN) }, 1, 4));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(9), new QFloat64(double.NaN), new QFloat64(24) }, 1, 5));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.PositiveInfinity), new QFloat64(double.NaN) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(9, double.NaN), new QFloat64(8, double.NaN) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(double.PositiveInfinity) }, 1, 2));

                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray());
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(3, 0, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(3, 0, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('r'), new QChar('o'), new QChar('w'), new QChar('s') }, 1, 4));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QFloat64NDimArray(3, 0));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('r'), new QChar('o'), new QChar('w'), new QChar('s') }, 1, 4));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.issorted(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            
            #region Cumprod
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c') }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(6) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(20), new QFloat64(6), new QFloat64(120) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18),
                                                                new QFloat64(7), new QFloat64(70), new QFloat64(8), new QFloat64(88), new QFloat64(9), new QFloat64(108)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(20), new QFloat64(6), new QFloat64(120),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(56), new QFloat64(110), new QFloat64(504), new QFloat64(1320)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(40), new QFloat64(16), new QFloat64(55), new QFloat64(27), new QFloat64(72)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                output.Add(new QFloat64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(2, 0, 3));
                output.Add(new QFloat64NDimArray(2, 0, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumprod(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Cumsum
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c') }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(10), new QFloat64(3), new QFloat64(18) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3), new QFloat64(6) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(7), new QFloat64(3), new QFloat64(9) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(3), new QFloat64(9), new QFloat64(6), new QFloat64(15) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(7), new QFloat64(3), new QFloat64(9),
                                                                new QFloat64(7), new QFloat64(17), new QFloat64(8), new QFloat64(19), new QFloat64(9), new QFloat64(21)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(3), new QFloat64(9), new QFloat64(6), new QFloat64(15),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(15), new QFloat64(21), new QFloat64(24), new QFloat64(33)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(8), new QFloat64(14), new QFloat64(10), new QFloat64(16), new QFloat64(12), new QFloat64(18)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6),
                                                                new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                output.Add(new QFloat64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(2, 0, 3));
                output.Add(new QFloat64NDimArray(2, 0, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.cumsum(args)));

            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region All
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.5) }, 1, 1));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(0), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 2, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(0), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true),
                                                                    new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(double.NaN) }, 1, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] {new QInt64(2)}, 1, 1));
                output.Add(new QBooleanNDimArray(0, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(1, 0, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true) }, 1, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.all(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Any
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(6) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.5) }, 1, 1));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[]{ new QFloat64(0), new QFloat64(0), new QFloat64(double.NaN), new QFloat64(0), new QFloat64(3), new QFloat64(0),
                                                        new QFloat64(7), new QFloat64(0), new QFloat64(8), new QFloat64(0), new QFloat64(9), new QFloat64(0)}, 2, 3, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true) }, 1, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[]{ new QInt64(0), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6),
                                                        new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12)}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true),
                                                                    new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true), new QBoolean(true)}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.NaN), new QFloat64(double.NaN) }, 1, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                output.Add(new QBooleanNDimArray(new QBoolean[] {new QBoolean(false) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QBooleanNDimArray(0, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(1, 0, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false) }, 1, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.any(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion


            #region Size
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1) }, 1, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1) }, 1, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
                
                args.RemoveAt(2);
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Clear();
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1) }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(6) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), new QInt64(1), }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray());
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(0, 1, 0));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray(0, 1, 0));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.size(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Sort
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch(NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6)}, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(0), new QFloat64(1), new QFloat64(5), new QFloat64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(0), new QInt64(1), new QInt64(5), new QInt64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Clear();
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(0), new QInt64(2), new QInt64(1), new QInt64(5), new QInt64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));

                args.RemoveAt(2);
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Clear();
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));

                args.RemoveAt(2);
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));
                output.Clear();
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5), new QInt64(6), new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(0), new QFloat64(5), new QFloat64(6) }, 2, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(0), new QFloat64(1), new QFloat64(5), new QFloat64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Clear();
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), new QFloat64(2), new QFloat64(1), new QFloat64(5), new QFloat64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));

                args.RemoveAt(2);
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Clear();
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(0), new QFloat64(5), new QFloat64(6) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));

                args.RemoveAt(2);
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));
                output.Clear();
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5), new QFloat64(6), new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(0) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6) }, 2, 3));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5), new QFloat64(6), new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(0) }, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6),
                                                            new QInt64(7), new QInt64(-2), new QInt64(10), new QInt64(12), new QInt64(3), new QInt64(4),}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));

                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(7), new QInt64(1), new QInt64(10), new QInt64(12), new QInt64(5), new QInt64(6),
                                                            new QInt64(2), new QInt64(-2), new QInt64(1), new QInt64(0), new QInt64(3), new QInt64(4),}, 2, 3, 2));
                
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(0), new QFloat64(5), new QFloat64(6),
                                                            new QFloat64(7), new QFloat64(-2), new QFloat64(10), new QFloat64(12), new QFloat64(3), new QFloat64(4),}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));

                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7), new QFloat64(1), new QFloat64(10), new QFloat64(12), new QFloat64(5), new QFloat64(6),
                                                            new QFloat64(2), new QFloat64(-2), new QFloat64(1), new QFloat64(0), new QFloat64(3), new QFloat64(4),}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1), new QInt64(1), new QInt64(0), new QInt64(5), new QInt64(6),
                                                            new QInt64(7), new QInt64(-2), new QInt64(10), new QInt64(12), new QInt64(3), new QInt64(4),}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));

                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(7), new QInt64(1), new QInt64(10), new QInt64(12), new QInt64(5), new QInt64(6),
                                                            new QInt64(2), new QInt64(-2), new QInt64(1), new QInt64(0), new QInt64(3), new QInt64(4),}, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(2), new QFloat64(2), new QFloat64(1), new QFloat64(1),
                                                            new QFloat64(1), new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(2), new QFloat64(2),}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(0), new QFloat64(5), new QFloat64(6),
                                                            new QFloat64(7), new QFloat64(-2), new QFloat64(10), new QFloat64(12), new QFloat64(3), new QFloat64(4),}, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));

                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(7), new QFloat64(1), new QFloat64(10), new QFloat64(12), new QFloat64(5), new QFloat64(6),
                                                            new QFloat64(2), new QFloat64(-2), new QFloat64(1), new QFloat64(0), new QFloat64(3), new QFloat64(4),}, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(2), new QFloat64(2), new QFloat64(1), new QFloat64(1),
                                                            new QFloat64(1), new QFloat64(2), new QFloat64(1), new QFloat64(1), new QFloat64(2), new QFloat64(2),}, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] {new QFloat64(double.NaN), new QFloat64(double.NaN), new QFloat64(double.PositiveInfinity)}, 3, 1 ));

                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(double.PositiveInfinity), new QFloat64(double.NaN), new QFloat64(double.NaN)}, 3, 1 ));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(1), new QFloat64(2) }, 3, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray());

                output.Add(new QFloat64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray());

                output.Add(new QFloat64NDimArray());
                output.Add(new QFloat64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(1, 0, 2));

                output.Add(new QFloat64NDimArray(1, 0, 2));
                output.Add(new QFloat64NDimArray(1, 0, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('b'), new QChar('c'), new QChar('a') }, 1, 3));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c') }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3), new QFloat64(1), new QFloat64(2) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('b'), new QChar('c'), new QChar('a') }, 1, 3));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('c'), new QChar('b'), new QChar('a') }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('b'), new QChar('c'), new QChar('a') }, 1, 3));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d'), new QChar('e'), new QChar('s'), new QChar('c'), new QChar('e'), new QChar('n'), new QChar('d') }, 1, 7));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('c'), new QChar('b'), new QChar('a') }, 1, 3));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1), new QFloat64(3) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.sort(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region Permute
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c') }, 1, 3));
                
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[]{new QInt64(2), new QInt64(4), new QInt64(1), new QInt64(3)}, 1, 4));
                args.Add(new QInt64NDimArray(new QInt64[]{new QInt64(2), new QInt64(4), new QInt64(1), new QInt64(3)}, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(4), new QInt64(1), new QInt64(8) }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(4), new QInt64(1) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(4), new QInt64(1), new QInt64(2) }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3)}, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1)}, 1, 2));
                output.Add(new QInt64NDimArray(new QInt64[]{new QInt64(1), new QInt64(2), new QInt64(3)}, 3, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(4), new QInt64(2), new QInt64(5), new QInt64(3), new QInt64(6), new QInt64(7), new QInt64(10), new QInt64(8), new QInt64(11), new QInt64(9), new QInt64(12),
                                                        new QInt64(2), new QInt64(8), new QInt64(4), new QInt64(10), new QInt64(6), new QInt64(12), new QInt64(1), new QInt64(7), new QInt64(3), new QInt64(9), new QInt64(5), new QInt64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(4), new QInt64(1), new QInt64(3) }, 1, 4));
                output.Add(new QInt64NDimArray(new QInt64[]{new QInt64(1), new QInt64(2), new QInt64(3), new QInt64(2), new QInt64(4), new QInt64(6), new QInt64(4), new QInt64(5), new QInt64(6), new QInt64(8), new QInt64(10), new QInt64(12),
                                                                new QInt64(7), new QInt64(8), new QInt64(9), new QInt64(1), new QInt64(3), new QInt64(5), new QInt64(10), new QInt64(11), new QInt64(12), new QInt64(7), new QInt64(9), new QInt64(11)}, 3, 2, 2, 2)); 
                
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12),
                                                        new QFloat64(2), new QFloat64(8), new QFloat64(4), new QFloat64(10), new QFloat64(6), new QFloat64(12), new QFloat64(1), new QFloat64(7), new QFloat64(3), new QFloat64(9), new QFloat64(5), new QFloat64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(4), new QInt64(1), new QInt64(3) }, 1, 4));
                output.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(2), new QFloat64(4), new QFloat64(6), new QFloat64(4), new QFloat64(5), new QFloat64(6), new QFloat64(8), new QFloat64(10), new QFloat64(12),
                                                                new QFloat64(7), new QFloat64(8), new QFloat64(9), new QFloat64(1), new QFloat64(3), new QFloat64(5), new QFloat64(10), new QFloat64(11), new QFloat64(12), new QFloat64(7), new QFloat64(9), new QFloat64(11)}, 3, 2, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12),
                                                        new QFloat64(2), new QFloat64(8), new QFloat64(4), new QFloat64(10), new QFloat64(6), new QFloat64(12), new QFloat64(1), new QFloat64(7), new QFloat64(3), new QFloat64(9), new QFloat64(5), new QFloat64(11)}, 2, 3, 2, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2.3), new QFloat64(4, 3), new QFloat64(1), new QFloat64(3) }, 1, 4));
                output.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(2), new QFloat64(4), new QFloat64(6), new QFloat64(4), new QFloat64(5), new QFloat64(6), new QFloat64(8), new QFloat64(10), new QFloat64(12),
                                                                new QFloat64(7), new QFloat64(8), new QFloat64(9), new QFloat64(1), new QFloat64(3), new QFloat64(5), new QFloat64(10), new QFloat64(11), new QFloat64(12), new QFloat64(7), new QFloat64(9), new QFloat64(11)}, 3, 2, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12),
                                                        new QFloat64(2), new QFloat64(8), new QFloat64(4), new QFloat64(10), new QFloat64(6), new QFloat64(12), new QFloat64(1), new QFloat64(7), new QFloat64(3), new QFloat64(9), new QFloat64(5), new QFloat64(11)}, 2, 3, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(4), new QInt64(5), new QInt64(1), new QInt64(3) }, 1, 5));
                output.Add(new QFloat64NDimArray(new QFloat64[]{new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(2), new QFloat64(4), new QFloat64(6), new QFloat64(4), new QFloat64(5), new QFloat64(6), new QFloat64(8), new QFloat64(10), new QFloat64(12),
                                                                new QFloat64(7), new QFloat64(8), new QFloat64(9), new QFloat64(1), new QFloat64(3), new QFloat64(5), new QFloat64(10), new QFloat64(11), new QFloat64(12), new QFloat64(7), new QFloat64(9), new QFloat64(11)}, 3, 2, 1, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3)}, 1, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3), new QInt64(1), new QInt64(2) }, 1, 3));
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3) }, 1, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(1) }, 1, 2));
                output.Add(new QInt64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(3), new QInt64(2) }, 1, 3));
                output.Add(new QInt64NDimArray(0, 1, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(3), new QUInt64(2) }, 1, 3));
                args.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(2), new QUInt64(1) }, 1, 2));
                output.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(3), new QUInt64(2) }, 3, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1) }, 1, 2));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(true) }, 3, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c') }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(1) }, 1, 2));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c') }, 3, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.permute(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Find
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(4) }, 1, 1));
                
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4), new QFloat64(10) }, 2, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 1, 12));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4), new QFloat64(10) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 2, 3, 2));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(-3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('l'), new QChar('a'), new QChar('s'), new QChar('t') }, 1, 4));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(10) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 1, 12));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(1) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4), new QFloat64(10) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(1), new QInt64(0), new QInt64(0) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2) }, 2, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(5) }, 2, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(78), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(0), new QInt64(29), new QInt64(0), new QInt64(0) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(2) }, 2, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(5) }, 2, 1));
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(78), new QInt64(29) }, 2, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0), new QFloat64(0), new QFloat64(78), new QFloat64(0), new QFloat64(0), new QFloat64(0), new QFloat64(0), new QFloat64(0), new QFloat64(29), new QFloat64(0), new QFloat64(0) }, 1, 12));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(1) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4), new QFloat64(10) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(78), new QFloat64(29) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray());
                output.Add(new QFloat64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray());
                output.Add(new QFloat64NDimArray());
                output.Add(new QFloat64NDimArray());
                output.Add(new QInt64NDimArray());

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0), new QInt64(0), new QInt64(0) }, 1, 3));
                output.Add(new QFloat64NDimArray(1, 0));
                output.Add(new QFloat64NDimArray(1, 0));
                output.Add(new QInt64NDimArray(1, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(0), new QUInt64(0), new QUInt64(0) }, 1, 3));
                output.Add(new QFloat64NDimArray(1, 0));
                output.Add(new QFloat64NDimArray(1, 0));
                output.Add(new QUInt64NDimArray(1, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false), new QBoolean(false) }, 1, 3));
                output.Add(new QFloat64NDimArray(1, 0));
                output.Add(new QFloat64NDimArray(1, 0));
                output.Add(new QBooleanNDimArray(1, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.find(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Reshape
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.5) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2.5) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3), new QInt64(4) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 3, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3)}, 1, 1));
                args.Add(new QInt64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 3, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray());
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 3, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                output.Add(new QFloat64NDimArray(3, 0, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray());
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0) }, 1, 1));
                output.Add(new QFloat64NDimArray(3, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.reshape(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Filter
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4) }, 2, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3), new QFloat64(2), new QFloat64(3) }, 2, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2), new QInt64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2), new QInt64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3), new QFloat64(2), new QFloat64(3) }, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d'), new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d'), new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d') }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2.25), new QFloat64(1), new QFloat64(3), new QFloat64(1.5), new QFloat64(3.75), new QFloat64(3.5), new QFloat64(6.75), new QFloat64(4), new QFloat64(7.5), new QFloat64(4.5), new QFloat64(8.25)}, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2.125), new QFloat64(6), new QFloat64(3.5), new QFloat64(7.5), new QFloat64(4.875), new QFloat64(9), new QFloat64(10.375), new QFloat64(15), new QFloat64(11.75), new QFloat64(16.5), new QFloat64(13.125), new QFloat64(18) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.5), new QFloat64(4.75), new QFloat64(3), new QFloat64(5), new QFloat64(4.5), new QFloat64(5.25), new QFloat64(10.5), new QFloat64(6.25), new QFloat64(12), new QFloat64(6.5), new QFloat64(13.5), new QFloat64(6.75) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1.625), new QFloat64(6), new QFloat64(0.5), new QFloat64(7.5), new QFloat64(2.625), new QFloat64(9), new QFloat64(11.125), new QFloat64(15), new QFloat64(13.25), new QFloat64(16.5), new QFloat64(15.375), new QFloat64(18) }, 2, 3, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3), new QFloat64(2), new QFloat64(4), new QFloat64(5), new QFloat64(7), new QFloat64(6), new QFloat64(8), new QFloat64(9), new QFloat64(11), new QFloat64(10), new QFloat64(12) }, 2, 2, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.5), new QFloat64(4), new QFloat64(6), new QFloat64(8.5), new QFloat64(10.5), new QFloat64(13), new QFloat64(5.25), new QFloat64(7), new QFloat64(4), new QFloat64(5.75), new QFloat64(2.75), new QFloat64(4.5) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.625), new QFloat64(10.5), new QFloat64(5.5), new QFloat64(15), new QFloat64(5), new QFloat64(12), new QFloat64(9.875), new QFloat64(16.5), new QFloat64(9.375), new QFloat64(13.5), new QFloat64(14.25), new QFloat64(18) }, 2, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(3), new QFloat64(2), new QFloat64(4), new QFloat64(5), new QFloat64(7), new QFloat64(6), new QFloat64(8), new QFloat64(9), new QFloat64(11), new QFloat64(10), new QFloat64(12) }, 2, 2, 3));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1.5), new QFloat64(4), new QFloat64(6), new QFloat64(8.5), new QFloat64(10.5), new QFloat64(13), new QFloat64(5.25), new QFloat64(7), new QFloat64(4), new QFloat64(5.75), new QFloat64(2.75), new QFloat64(4.5) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.625), new QFloat64(10.5), new QFloat64(5.5), new QFloat64(15), new QFloat64(5), new QFloat64(12), new QFloat64(9.875), new QFloat64(16.5), new QFloat64(9.375), new QFloat64(13.5), new QFloat64(14.25), new QFloat64(18) }, 2, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) }, 1, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(3) }, 1, 2));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(4), new QFloat64(2), new QFloat64(5), new QFloat64(3), new QFloat64(6), new QFloat64(7), new QFloat64(10), new QFloat64(8), new QFloat64(11), new QFloat64(9), new QFloat64(12) }, 2, 3, 2));
                args.Add(new QFloat64NDimArray());
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(2), new QFloat64(1), new QFloat64(2.5), new QFloat64(1.5), new QFloat64(3), new QFloat64(3.75), new QFloat64(6), new QFloat64(4.5), new QFloat64(6.75), new QFloat64(5.25), new QFloat64(7.5) }, 2, 3, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2.875), new QFloat64(10.5), new QFloat64(7), new QFloat64(15), new QFloat64(4.25), new QFloat64(12), new QFloat64(8.375), new QFloat64(16.5), new QFloat64(5.625), new QFloat64(13.5), new QFloat64(9.75), new QFloat64(18) }, 2, 2, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.filter(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }
            #endregion

            #region Colon
            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1)); 

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(5) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4), new QFloat64(5) }, 1, 5));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('d') }, 1, 1));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d') }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d') }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d') }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(5) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, 1, 1));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('b'), new QChar('c'), new QChar('d') }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('c') }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('g') }, 1, 1));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('e'), new QChar('g') }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('g') }, 1, 1));
                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('e'), new QChar('g') }, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(0.7, 2) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2), new QFloat64(0.4) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-0.2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5)}, 1, 1));
                output.Add(new QFloat64NDimArray(1, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2) }, 1, 1));
                output.Add(new QFloat64NDimArray(1, 0));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-0.2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.2) }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0.5), new QFloat64(0.3) }, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b'), new QChar('d'), new QChar('e'), new QChar('g'), new QChar('f'), new QChar('h') }, 2, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(0) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b'), new QChar('d'), new QChar('e'), new QChar('g'), new QChar('f'), new QChar('h') }, 2, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('+') }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b'), new QChar('d'), new QChar('e'), new QChar('g'), new QChar('f'), new QChar('h') }, 2, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(-1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 4, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(-1) }, 1, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(false), new QBoolean(true), new QBoolean(true), new QBoolean(false) }, 2, 3));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                output.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false) }, 1, 3));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('b'), new QChar('d'), new QChar('e'), new QChar('g'), new QChar('f'), new QChar('h') }, 2, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1) }, 1, 2));

                output.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('c'), new QChar('e'), new QChar('g'), new QChar('a'), new QChar('c'), new QChar('e'), new QChar('g') }, 2, 1, 2, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 4, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 32, 1));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 4, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 16));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 4, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(9), new QFloat64(13), new QFloat64(4), new QFloat64(8), new QFloat64(12), new QFloat64(16) }, 2, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(5), new QInt64(2), new QInt64(6), new QInt64(3), new QInt64(7), new QInt64(4), new QInt64(8),
                                                            new QInt64(9), new QInt64(13), new QInt64(10), new QInt64(14), new QInt64(11), new QInt64(15), new QInt64(12), new QInt64(16),
                                                            new QInt64(4), new QInt64(8), new QInt64(3), new QInt64(7), new QInt64(2), new QInt64(6), new QInt64(1), new QInt64(5),
                                                            new QInt64(12), new QInt64(16), new QInt64(11), new QInt64(15), new QInt64(10), new QInt64(14), new QInt64(9), new QInt64(13)}, 2, 4, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                output.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(5), new QInt64(9), new QInt64(13), new QInt64(4), new QInt64(8), new QInt64(12), new QInt64(16) }, 2, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(5), new QUInt64(2), new QUInt64(6), new QUInt64(3), new QUInt64(7), new QUInt64(4), new QUInt64(8),
                                                            new QUInt64(9), new QUInt64(13), new QUInt64(10), new QUInt64(14), new QUInt64(11), new QUInt64(15), new QUInt64(12), new QUInt64(16),
                                                            new QUInt64(4), new QUInt64(8), new QUInt64(3), new QUInt64(7), new QUInt64(2), new QUInt64(6), new QUInt64(1), new QUInt64(5),
                                                            new QUInt64(12), new QUInt64(16), new QUInt64(11), new QUInt64(15), new QUInt64(10), new QUInt64(14), new QUInt64(9), new QUInt64(13)}, 2, 4, 2, 2));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                output.Add(new QUInt64NDimArray(new QUInt64[] { new QUInt64(1), new QUInt64(5), new QUInt64(9), new QUInt64(13), new QUInt64(4), new QUInt64(8), new QUInt64(12), new QUInt64(16) }, 2, 1, 4));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 4, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(1) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(10), new QFloat64(2), new QFloat64(10) }, 1, 1, 2, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                List<IQLabValue> output = new List<IQLabValue>();
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(2), new QFloat64(6), new QFloat64(3), new QFloat64(7), new QFloat64(4), new QFloat64(8),
                                                            new QFloat64(9), new QFloat64(13), new QFloat64(10), new QFloat64(14), new QFloat64(11), new QFloat64(15), new QFloat64(12), new QFloat64(16),
                                                            new QFloat64(4), new QFloat64(8), new QFloat64(3), new QFloat64(7), new QFloat64(2), new QFloat64(6), new QFloat64(1), new QFloat64(5),
                                                            new QFloat64(12), new QFloat64(16), new QFloat64(11), new QFloat64(15), new QFloat64(10), new QFloat64(14), new QFloat64(9), new QFloat64(13)}, 2, 4, 2, 2));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(2) }, 1, 1));
                args.Add(new QCharNDimArray(new QChar[] { new QChar(':') }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1) }, 1, 1));
                args.Add(new QInt64NDimArray(new QInt64[] { new QInt64(1), new QInt64(2) }, 1, 2));
                output.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(10), new QFloat64(2), new QFloat64(10) }, 1, 1, 2, 1, 2));

                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(output, f.colon(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, true);
            }
            #endregion

            #region regex

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();

                List<string> strings = new List<string>();
                strings.Add("one two 3, 4 five");
                QCharNDimArray arg = Helper.StringListToQCharNDimArray(strings);
                args.Add(arg);

                List<string> strings1 = new List<string>();
                strings1.Add("[0-9]+");
                QCharNDimArray arg1 = Helper.StringListToQCharNDimArray(strings);
                args.Add(arg1);

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(8), new QFloat64(10) }, new int[] { 2, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.length(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #endregion
            #region Tests of functions added by AM

            
            #region length tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4), new QFloat64(5), new QFloat64(6) },
                    new int[] { 3, 2 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(3) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.length(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region nonzeros test

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), new QFloat64(3), new QFloat64(0), new QFloat64(5), new QFloat64(0) },
                    new int[] { 2, 3 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(3) }, new int[] { 1, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.nonzeros(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region numel

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), new QFloat64(3), new QFloat64(0), new QFloat64(5), new QFloat64(0) },
                    new int[] { 2, 3 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(6) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.numel(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region nzmax tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), new QFloat64(3), new QFloat64(0), new QFloat64(5), new QFloat64(0) },
                    new int[] { 2, 3 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(6) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.nzmax(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region isstrprop tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar(' '), new QChar('A') }, new int[] { 1, 3 }));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('w'), new QChar('s'), new QChar('p'), new QChar('a'), new QChar('c'), new QChar('e') }, new int[] { 1, 6 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(true), new QBoolean(false) }, new int[] { 1, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.isstrprop(args)));

                args.Clear();
                result.Clear();

                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar(' '), new QChar('A') }, new int[] { 1, 3 }));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('l'), new QChar('o'), new QChar('w'), new QChar('e'), new QChar('r') }, new int[] { 1, 5 }));

                result.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true), new QBoolean(false), new QBoolean(false) }, new int[] { 1, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.isstrprop(args)));

                args.Clear();
                result.Clear();

                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar(' '), new QChar('A') }, new int[] { 1, 3 }));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('u'), new QChar('p'), new QChar('p'), new QChar('e'), new QChar('r') }, new int[] { 1, 5 }));

                result.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(false), new QBoolean(false), new QBoolean(true) }, new int[] { 1, 3 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.isstrprop(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region tril tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), new QFloat64(0), new QFloat64(4),
                    new QFloat64(5), new QFloat64(0), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.tril(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, new int[] { 1, 1 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(0), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.tril(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1) }, new int[] { 1, 1 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(0), new QFloat64(0), new QFloat64(4),
                    new QFloat64(0), new QFloat64(0), new QFloat64(7), new QFloat64(8), new QFloat64(0) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.tril(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region triu tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(0),
                    new QFloat64(5), new QFloat64(6), new QFloat64(0), new QFloat64(0), new QFloat64(9) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.triu(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, new int[] { 1, 1 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(0), new QFloat64(2), new QFloat64(3), new QFloat64(0),
                    new QFloat64(0), new QFloat64(6), new QFloat64(0), new QFloat64(0), new QFloat64(0) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.triu(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1) }, new int[] { 1, 1 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(0), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.triu(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region diag tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));

                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(5), new QFloat64(9) },
                    new int[] { 1, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.diag(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1) }, new int[] { 1, 1 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(2), new QFloat64(6) },
                    new int[] { 1, 2 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.diag(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3), new QFloat64(4),
                    new QFloat64(5), new QFloat64(6), new QFloat64(7), new QFloat64(8), new QFloat64(9) },
                    new int[] { 3, 3 }));
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(-1) }, new int[] { 1, 1 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(4), new QFloat64(8) },
                    new int[] { 1, 2 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.diag(args)));

                args.Clear();
                result.Clear();
                args.Add(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(2), new QFloat64(3) },
                    new int[] { 1, 3 }));

                result.Add(new QFloat64NDimArray(new QFloat64NDimArray(new QFloat64[] { new QFloat64(1), new QFloat64(0), new QFloat64(0), new QFloat64(0),
                    new QFloat64(2), new QFloat64(0), new QFloat64(0), new QFloat64(0), new QFloat64(3) },
                    new int[] { 3, 3 })));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.diag(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #region setenv and getenv tests

            try
            {
                List<IQLabValue> args = new List<IQLabValue>();
                args.Add(new QCharNDimArray(new QChar[] { new QChar('t'), new QChar('e'), new QChar('s'), new QChar('t') }, new int[] { 1, 4 }));
                args.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('a'), new QChar('a') }));
                List<IQLabValue> result = new List<IQLabValue>();
                result.Add(new QBooleanNDimArray(new QBoolean[] { new QBoolean(true) }, new int[] { 1, 1 }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.setenv(args)));

                args.Clear();
                result.Clear();

                args.Add(new QCharNDimArray(new QChar[] { new QChar('t'), new QChar('e'), new QChar('s'), new QChar('t') }, new int[] { 1, 4 }));
                result.Add(new QCharNDimArray(new QChar[] { new QChar('a'), new QChar('a'), new QChar('a') }));
                Assert.AreEqual(true, Helper.areIQlabValueListsEqual(result, f.getenv(args)));
            }
            catch (NumericalCalculationsException ex)
            {
                Assert.AreEqual(true, false);
            }

            #endregion

            #endregion        
        }

    }
}
